![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to x11term.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to x11term.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 root 1: /* X Communication module for terminals which understand the X protocol.
2: Copyright (C) 1988, 1990 Free Software Foundation, Inc.
3:
4: This file is part of GNU Emacs.
5:
6: GNU Emacs is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 1, or (at your option)
9: any later version.
10:
11: GNU Emacs is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU Emacs; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /* Written by Yakim Martillo, mods and things by Robert Krawitz */
21: /* Redone for X11 by Robert French */
22: /* Thanks to Mark Biggers for all of the Window Manager support */
23:
24: /*
25: * $Source: /mit/emacs/src/RCS/11xterm.c,v $
26: * $Author: rfrench $
27: * $Locker: $
28: * $Header: x11term.c,v 1.12 88/02/29 14:11:07 rfrench Exp $
29: */
30:
31: #ifndef lint
32: static char *rcsid_xterm_c = "$Header: x11term.c,v 1.12 88/02/29 14:11:07 rfrench Exp $";
33: #endif lint
34:
35: /* On 4.3 this loses if it comes after x11term.h.
36: On hp-ux it loses if it comes after config.h. */
37: #include <signal.h>
38: #include <sys/ioctl.h>
39:
40: /* Load sys/types.h if not already loaded.
41: In some systems loading it twice is suicidal. */
42: #ifndef makedev
43: #include <sys/types.h>
44: #endif
45:
46: #include "config.h"
47:
48: #ifdef HAVE_X_WINDOWS
49:
50: /* Get FIONREAD, if it is available.
51: It would be logical to include <sys/ioctl.h> here,
52: but it was moved up above to avoid problems. */
53: #ifdef USG
54: #include <termio.h>
55: #endif /* USG */
56: #include <fcntl.h>
57:
58: #include "lisp.h"
59: #undef NULL
60:
61: /* Allow m- file to inhibit use of interrupt-driven input. */
62: #ifdef BROKEN_FIONREAD
63: #undef FIONREAD
64: #endif
65:
66: /* We are unable to use interrupts if FIONREAD is not available,
67: so flush SIGIO so we won't try. */
68: #ifndef FIONREAD
69: #ifdef SIGIO
70: #undef SIGIO
71: #endif
72: #endif
73:
74: /* This may include sys/types.h, and that somehow loses
75: if this is not done before the other system files.
76: However, perhaps the problem has been avoided by loading types.h above. */
77:
78: #include "x11term.h"
79:
80: #include "X11/Xresource.h"
81:
82: /* Allow the config file to specify whether we can assume X11R4. */
83: #ifdef SPECIFY_X11R4
84: #if SPECIFY_X11R4 > 0
85: #define X11R4
86: #endif
87: #else /* not SPECIFY_X11R4 */
88: /* Try to guess whether this is release 4 or newer. */
89: #ifdef PBaseSize
90: #define X11R4
91: #endif
92: #endif /* not SPECIFY_X11R4 */
93:
94: #ifdef HAVE_SOCKETS
95: #include <sys/socket.h> /* Must be done before gettime.h. */
96: #endif
97: /* Include time.h, sys/time.h, or both. */
98: #include "gettime.h"
99:
100: #ifdef AIX
101: static KeySym XMOD_Alt[] = { XK_Alt_L };
102: static KeySym XMOD_Shift[] = { XK_Shift_L };
103: static KeySym XMOD_ShiftAlt[] = { XK_Alt_L, XK_Shift_L };
104: static KeySym XMOD_CtrlAlt[] = { XK_Control_L, XK_Alt_L };
105: static KeySym XMOD_Ctrl[] = { XK_Control_L };
106: static KeySym XMOD_CtrlShift[] = { XK_Control_L, XK_Shift_L };
107: static KeySym XMOD_ShiftCtrlAlt[] = { XK_Control_L, XK_Alt_L, XK_Shift_L };
108: #endif
109:
110: #if 0 /* On some machines, stdio.h doesn't define NULL
111: if stddef.h has been included already! */
112: #ifdef NULL /* Sometimes various definitions conflict here. */
113: #undef NULL
114: #endif
115: #endif
116: #include <stdio.h>
117: #include <ctype.h>
118: #include <errno.h>
119: #ifdef BSD
120: #include <strings.h>
121: #endif
122: #include <sys/stat.h>
123:
124: #ifndef NULL
125: #define NULL 0
126: #endif
127:
128: #include "dispextern.h"
129: #include "termhooks.h"
130: #include "termopts.h"
131: #include "termchar.h"
132:
133: #include "sink11.h"
134: #include "sink11mask.h"
135:
136: #define min(a,b) ((a)<(b) ? (a) : (b))
137: #define max(a,b) ((a)>(b) ? (a) : (b))
138:
139: extern int errno;
140:
141: #define sigunblockx(sig) sigblock (SIGEMPTYMASK)
142: #define sigblockx(sig) sigblock (sigmask ((sig)))
143:
144: #define METABIT 0200
145: #define MINWIDTH 12 /* In pixels */
146: #define MINHEIGHT 5 /* In pixels */
147: #define MAXHEIGHT 300 /* In lines */
148:
149: int pixelwidth,pixelheight;
150: char *progname;
151:
152: XEvent *XXm_queue[XMOUSEBUFSIZE];
153: int XXm_queue_num, XXm_queue_in, XXm_queue_out;
154:
155: char *XXcurrentfont;
156: XFontStruct *fontinfo;
157: Font XXfid;
158: int XXfontw, XXfonth, XXbase, XXisColor;
159:
160: /* Nonzero means Emacs has explicit keyboard focus. */
161: int x_focus_flag;
162:
163: Colormap XXColorMap;
164: char *default_window;
165: extern int initialized;
166: extern int screen_width, screen_height;
167: extern int delayed_size_change;
168:
169: /* Function for init_keyboard to call with no args (if nonzero). */
170: extern void (*keyboard_init_hook) ();
171:
172: extern char *alternate_display;
173: extern int xargc;
174: extern char **xargv;
175:
176: int XXdebug;
177: int XXpid;
178:
179: int WindowMapped;
180:
181: char *XXidentity; /* Resource name of this invocation of Emacs */
182: static char *XXicon_name; /* user-supplied icon info */
183: static int XXicon_usebitmap; /* Use bitmap or not */
184: static char *XXheader; /* user-supplied window header info */
185:
186: static int flexlines; /* last line affected by dellines or
187: * inslines functions */
188: int VisibleX, VisibleY; /* genuine location of cursor on screen
189: * if it is there */
190:
191: /* Last cursor position specified by move_cursor.
192: During an update, this does not display a cursor on the screen;
193: But it controls the position that is output. */
194: static int local_cursor_hpos;
195: static int local_cursor_vpos;
196:
197: static int SavedX, SavedY; /* Where the cursor was before update
198: * started */
199:
200:
201: int CursorExists; /* during updates cursor is turned off */
202: int CursorOutline; /* when the pointer is not in the Emacs
203: * widow the cursor should be drawn in
204: * outline form a la xterm */
205: static int InUpdate; /* many of functions here may be invoked
206: * even if no update in progress; when
207: * no update is in progress the action
208: * can be slightly different */
209:
210: Display *XXdisplay;
211: int XXscreen;
212: Window XXwindow;
213: GC XXgc_norm,XXgc_rev,XXgc_curs,XXgc_temp,XXgc_curs_rev;
214: XGCValues XXgcv;
215: Cursor EmacsCursor;
216: Pixmap SinkPixmap, SinkMaskPixmap;
217:
218: static XrmDatabase db, db2;
219:
220: char *fore_color; /* Variables to store color names */
221: char *back_color;
222: char *brdr_color;
223: char *curs_color;
224: char *mous_color;
225:
226: unsigned long fore; /* Variables to store pixel values */
227: unsigned long back;
228: unsigned long brdr;
229: unsigned long curs;
230:
231: char *desiredwindow;
232:
233: int CurHL; /* Current Highlighting (ala mode line) */
234:
235: int XXborder; /* Window border width */
236: int XXInternalBorder; /* Internal border width */
237: int updated[MAXHEIGHT];
238:
239: static char *temp_font; /* needed because of loading hacks */
240: static char *temp_reverseVideo;
241: static char *temp_borderWidth;
242: static char *temp_internalBorder;
243: static char *temp_useBitmap;
244:
245: struct _xdeftab
246: {
247: char *iname; /* instance name */
248: char *cname; /* class name (fake it) */
249: char **varp; /* variable to set */
250: };
251:
252: static struct _xdeftab xDefaultsValueTable[]
253: = {
254: { "reverseVideo", "ReverseVideo", &temp_reverseVideo },
255: { "borderWidth", "BorderWidth", &temp_borderWidth },
256: { "internalBorder","BorderWidth", &temp_internalBorder },
257: { "bitmapIcon", "BitmapIcon", &temp_useBitmap },
258: { "borderColor", "BorderColor", &brdr_color },
259: { "background", "Background", &back_color },
260: { "foreground", "Foreground", &fore_color },
261: { "pointerColor", "Foreground", &mous_color },
262: { "cursorColor", "Foreground", &curs_color },
263: { "font", "Font", &temp_font },
264: { "geometry", "Geometry", &desiredwindow },
265: { "title", "Title", &XXheader },
266: { "iconName", "Title", &XXicon_name },
267: { NULL, NULL, NULL }
268: };
269:
270:
271: int (*handler)();
272:
273: static void x_init_1 ();
274: static int XInitWindow ();
275:
276: char *rindex();
277:
278: /* HLmode -- Changes the GX function for output strings. Could be used to
279: * change font. Check an XText library function call.
280: */
281:
282: HLmode (new)
283: int new;
284: {
285: extern Lisp_Object inverse_video;
286:
287: CurHL = new;
288: }
289:
290: /* External interface to control of standout mode.
291: Call this when about to modify line at position VPOS
292: and not change whether it is highlighted. */
293:
294: XTreassert_line_highlight (highlight, vpos)
295: int highlight, vpos;
296: {
297: HLmode (highlight);
298: }
299:
300: /* Call this when about to modify line at position VPOS
301: and change whether it is highlighted. */
302:
303: XTchange_line_highlight (new_highlight, vpos, first_unused_hpos)
304: int new_highlight, vpos, first_unused_hpos;
305: {
306: HLmode (new_highlight);
307: XTmove_cursor (vpos, 0);
308: x_clear_end_of_line (0);
309: }
310:
311:
312: /* Used for starting or restarting (after suspension) the X window. Puts the
313: * cursor in a known place, update does not begin with this routine but only
314: * with a call to redisplay.
315: */
316:
317: XTset_terminal_modes ()
318: {
319: int stuffpending;
320: #ifdef XDEBUG
321: fprintf (stderr, "XTset_terminal_modes\n");
322: #endif
323:
324: InUpdate = 0;
325: stuffpending = 0;
326: if (!initialized) {
327: CursorExists = 0;
328: CursorOutline = 1;
329: VisibleX = 0;
330: VisibleY = 0;
331: }
332: XTclear_screen ();
333: }
334:
335: /* XTmove_cursor moves the cursor to the correct location and checks whether an
336: * update is in progress in order to toggle it on.
337: */
338:
339: XTmove_cursor (row, col)
340: register int row, col;
341: {
342: BLOCK_INPUT_DECLARE ();
343: #ifdef XDEBUG
344: fprintf (stderr, "XTmove_cursor (X %d, Y %d)\n",col,row);
345: #endif
346:
347: BLOCK_INPUT ();
348: local_cursor_hpos = col;
349: local_cursor_vpos = row;
350:
351: if (InUpdate) {
352: if (CursorExists)
353: CursorToggle ();
354: UNBLOCK_INPUT ();
355: return;
356: /* Generally, XTmove_cursor will be invoked */
357: /* when InUpdate with !CursorExists */
358: /* so that wasteful XFlush is not called */
359: }
360: if ((row == VisibleY) && (col == VisibleX)) {
361: if (!CursorExists)
362: CursorToggle ();
363: XFlush (XXdisplay);
364: UNBLOCK_INPUT ();
365: return;
366: }
367: if (CursorExists)
368: CursorToggle ();
369: VisibleX = col;
370: VisibleY = row;
371: if (!CursorExists)
372: CursorToggle ();
373: XFlush (XXdisplay);
374: UNBLOCK_INPUT ();
375: }
376:
377: /* Used to get the terminal back to a known state after resets. Usually
378: * used when restarting suspended or waiting emacs
379: */
380:
381: cleanup ()
382: {
383: inverse_video = 0;
384: HLmode (0);
385: }
386:
387: /* Erase current line from current column to column END.
388: Leave cursor at END. */
389:
390: XTclear_end_of_line (end)
391: register int end;
392: {
393: register int numcols;
394: BLOCK_INPUT_DECLARE ();
395:
396: #ifdef XDEBUG
397: fprintf (stderr, "XTclear_end_of_line (to %d)\n",end);
398: #endif
399:
400: if (local_cursor_vpos < 0 || local_cursor_vpos >= screen_height)
401: return;
402:
403: if (end <= local_cursor_hpos)
404: return;
405: if (end >= screen_width)
406: end = screen_width;
407:
408: numcols = end - local_cursor_hpos;
409: BLOCK_INPUT ();
410: if (local_cursor_vpos == VisibleY && VisibleX >= local_cursor_hpos && VisibleX < end)
411: if (CursorExists) CursorToggle ();
412: if (CurHL)
413: XFillRectangle (XXdisplay, XXwindow, XXgc_norm,
414: local_cursor_hpos*XXfontw+XXInternalBorder,
415: local_cursor_vpos*XXfonth+XXInternalBorder,
416: XXfontw*numcols,
417: XXfonth);
418: else
419: XClearArea (XXdisplay, XXwindow,
420: local_cursor_hpos*XXfontw+XXInternalBorder,
421: local_cursor_vpos*XXfonth+XXInternalBorder,
422: XXfontw*numcols,
423: XXfonth,
424: 0);
425: XTmove_cursor (local_cursor_vpos, end);
426: UNBLOCK_INPUT ();
427: }
428:
429: /* Erase current line from column START to right margin.
430: Leave cursor at START. */
431:
432: x_clear_end_of_line (start)
433: register int start;
434: {
435: register int numcols;
436: BLOCK_INPUT_DECLARE ();
437:
438: #ifdef XDEBUG
439: fprintf (stderr, "x_clear_end_of_line (start %d)\n", start);
440: #endif
441:
442: if (local_cursor_vpos < 0 || local_cursor_vpos >= screen_height)
443: return;
444:
445: if (start >= screen_width)
446: return;
447: if (start < 0)
448: start = 0;
449:
450: numcols = screen_width - start;
451: BLOCK_INPUT ();
452: if (local_cursor_vpos == VisibleY && VisibleX >= start)
453: if (CursorExists) CursorToggle ();
454: if (CurHL)
455: XFillRectangle (XXdisplay, XXwindow, XXgc_norm,
456: start*XXfontw+XXInternalBorder,
457: local_cursor_vpos*XXfonth+XXInternalBorder,
458: XXfontw*numcols,
459: XXfonth);
460: else
461: XClearArea (XXdisplay, XXwindow,
462: start*XXfontw+XXInternalBorder,
463: local_cursor_vpos*XXfonth+XXInternalBorder,
464: XXfontw*numcols,
465: XXfonth,
466: 0);
467: XTmove_cursor (local_cursor_vpos, start);
468: UNBLOCK_INPUT ();
469: }
470:
471: XTreset_terminal_modes ()
472: {
473: #ifdef XDEBUG
474: fprintf (stderr, "XTreset_terminal_modes\n");
475: #endif
476:
477: XTclear_screen ();
478: }
479:
480: XTclear_screen ()
481: {
482: BLOCK_INPUT_DECLARE ();
483:
484: #ifdef XDEBUG
485: fprintf (stderr, "XTclear_screen\n");
486: #endif
487:
488: BLOCK_INPUT ();
489: HLmode (0);
490: CursorExists = 0;
491:
492: local_cursor_hpos = 0;
493: local_cursor_vpos = 0;
494: SavedX = 0;
495: SavedY = 0;
496: VisibleX = 0;
497: VisibleY = 0;
498: XClearWindow(XXdisplay, XXwindow);
499: CursorToggle ();
500: if (!InUpdate)
501: XFlush (XXdisplay);
502: UNBLOCK_INPUT ();
503: }
504:
505: /* used by dumprectangle which is usually invoked upon Expose
506: * events which come from bit blt's or moving an obscuring opaque window
507: */
508:
509: dumpchars (active_screen, numcols, tempX, tempY, tempHL)
510: register struct matrix *active_screen;
511: register int numcols;
512: register int tempX, tempY, tempHL;
513: {
514: if (numcols <= 0)
515: return;
516:
517: if (numcols-1+tempX > screen_width)
518: numcols = screen_width-tempX+1;
519:
520: if (tempX < 0 || tempX >= screen_width ||
521: tempY < 0 || tempY >= screen_height)
522: return;
523:
524: XDrawImageString(XXdisplay, XXwindow, tempHL ? XXgc_rev : XXgc_norm,
525: tempX*XXfontw+XXInternalBorder,
526: tempY*XXfonth+XXInternalBorder+XXbase,
527: (char *) &active_screen->contents[tempY][tempX],
528: numcols);
529: }
530:
531: /* When a line has been changed this function is called. Due to various
532: * bits of braindamage on the parts of both X11 and Emacs, the new
533: * version of the line is simply output if this function is invoked while
534: * in UpDate. Sometimes writechars can be invoked when not in update if
535: * text is to be output at the end of the line. In this case the whole
536: * line is not output. Simply the new text at the current cursor
537: * position given by VisibleX,Y. The cursor is moved to the end of the
538: * new text.
539: */
540:
541: updateline (first)
542: int first;
543: {
544: register int temp_length;
545: BLOCK_INPUT_DECLARE ();
546:
547: #ifdef XDEBUG
548: fprintf(stderr, "updateline\n");
549: #endif /* XDEBUG */
550:
551: BLOCK_INPUT ();
552: if ((local_cursor_vpos < 0) || (local_cursor_vpos >= screen_height)
553: || updated[local_cursor_vpos]) {
554: UNBLOCK_INPUT ();
555: return;
556: }
557: if (!first)
558: updated[local_cursor_vpos] = 1;
559: if (CursorExists)
560: CursorToggle ();
561: if (new_screen->enable[local_cursor_vpos])
562: temp_length = new_screen->used[local_cursor_vpos]-first;
563: else
564: temp_length = 0;
565: if (temp_length > 0) {
566: XDrawImageString (XXdisplay, XXwindow,
567: CurHL ? XXgc_rev : XXgc_norm,
568: first*XXfontw+XXInternalBorder,
569: local_cursor_vpos*XXfonth+XXInternalBorder+XXbase,
570: (char *) &new_screen->contents[local_cursor_vpos][first],
571: temp_length);
572: if (temp_length < screen_width)
573: x_clear_end_of_line (temp_length);
574: XTmove_cursor (local_cursor_vpos, temp_length);
575: }
576: else {
577: x_clear_end_of_line (0);
578: XTmove_cursor (local_cursor_vpos, 0);
579: }
580: UNBLOCK_INPUT ();
581: }
582:
583: writechars (start, end)
584: register char *start, *end;
585: {
586: BLOCK_INPUT_DECLARE ();
587:
588: #ifdef XDEBUG
589: fprintf(stderr, "writechars (local_cursor_hpos %d temp_len %d InUpd %d)\n",
590: local_cursor_hpos, end-start+1, InUpdate);
591: #endif /* XDEBUG */
592:
593: BLOCK_INPUT ();
594:
595: if ((local_cursor_vpos < 0) || (local_cursor_vpos >= screen_height))
596: {
597: UNBLOCK_INPUT ();
598: return;
599: }
600:
601: if (CursorExists)
602: CursorToggle ();
603:
604:
605: if (InUpdate)
606: {
607: XDrawImageString (XXdisplay, XXwindow,
608: CurHL ? XXgc_rev : XXgc_norm,
609: local_cursor_hpos*XXfontw+XXInternalBorder,
610: local_cursor_vpos*XXfonth+XXInternalBorder+XXbase,
611: start,
612: (end - start) + 1);
613: XTmove_cursor (local_cursor_vpos, (end - start) + 1);
614:
615: UNBLOCK_INPUT ();
616: return;
617: }
618:
619: if ((VisibleX < 0) || (VisibleX >= screen_width)) {
620: UNBLOCK_INPUT ();
621: return;
622: }
623: if ((VisibleY < 0) || (VisibleY >= screen_height)) {
624: UNBLOCK_INPUT ();
625: return;
626: }
627: if (((end - start) + VisibleX) >= screen_width)
628: end = start + (screen_width - (VisibleX + 1));
629: if (end >= start) {
630: XDrawImageString (XXdisplay, XXwindow,
631: CurHL ? XXgc_rev : XXgc_norm,
632: (VisibleX * XXfontw+XXInternalBorder),
633: VisibleY * XXfonth+XXInternalBorder+XXbase,
634: start,
635: ((end - start) + 1));
636: VisibleX = VisibleX + (end - start) + 1;
637: }
638: if (!CursorExists)
639: CursorToggle ();
640: UNBLOCK_INPUT ();
641: }
642:
643: static
644: XToutput_chars (start, len)
645: register char *start;
646: register int len;
647: {
648: #ifdef XDEBUG
649: fprintf (stderr, "XToutput_chars (len %d)\n",len);
650: #endif
651:
652: writechars (start, start+len-1);
653: }
654:
655: XTflash ()
656: {
657: #ifdef HAVE_TIMEVAL
658: #ifdef HAVE_SELECT
659: XGCValues gcv_temp;
660: struct timeval wakeup, now;
661: BLOCK_INPUT_DECLARE ();
662:
663: #ifdef XDEBUG
664: fprintf (stderr, "XTflash\n");
665: #endif
666:
667: BLOCK_INPUT ();
668: XXgc_temp = XCreateGC(XXdisplay, XXwindow, 0, &gcv_temp);
669: XSetState(XXdisplay, XXgc_temp, WhitePixel (XXdisplay, XXscreen),
670: BlackPixel(XXdisplay, XXscreen), GXinvert,
671: AllPlanes);
672:
673: /* For speed, flash just 1/4 of the window's area, a rectangle in
674: the center. */
675: XFillRectangle (XXdisplay, XXwindow, XXgc_temp,
676: screen_width*XXfontw/4, screen_height*XXfonth/4,
677: screen_width*XXfontw/2, screen_height*XXfonth/2);
678: XFlush (XXdisplay);
679:
680: UNBLOCK_INPUT ();
681:
682: gettimeofday (&wakeup, (struct timezone *)0);
683:
684: /* Compute time to wait until, propagating carry from usecs. */
685: wakeup.tv_usec += 150000;
686: wakeup.tv_sec += (wakeup.tv_usec / 1000000);
687: wakeup.tv_usec %= 1000000;
688:
689: /* Keep waiting until past the time wakeup. */
690: while (1)
691: {
692: struct timeval timeout;
693:
694: gettimeofday (&timeout, (struct timezone *)0);
695:
696: /* In effect, timeout = wakeup - timeout.
697: Break if result would be negative. */
698: if (timeval_subtract (&timeout, wakeup, timeout))
699: break;
700:
701: /* Try to wait that long--but we might wake up sooner. */
702: select (0, 0, 0, 0, &timeout);
703: }
704:
705: BLOCK_INPUT ();
706:
707: XFillRectangle (XXdisplay, XXwindow, XXgc_temp,
708: screen_width*XXfontw/4, screen_height*XXfonth/4,
709: screen_width*XXfontw/2, screen_height*XXfonth/2);
710:
711: XFreeGC(XXdisplay, XXgc_temp);
712: XFlush (XXdisplay);
713:
714: UNBLOCK_INPUT ();
715: #endif
716: #endif
717: }
718:
719: XTfeep ()
720: {
721: BLOCK_INPUT_DECLARE ();
722: #ifdef XDEBUG
723: fprintf (stderr, "XTfeep\n");
724: #endif
725: BLOCK_INPUT ();
726: XBell (XXdisplay, 0);
727: XFlush (XXdisplay);
728: UNBLOCK_INPUT ();
729: }
730:
731: /* Artificially creating a cursor is hard, the actual position on the
732: * screen (either where it is or last was) is tracked with VisibleX,Y.
733: * Gnu Emacs code tends to assume a cursor exists in hardward at local_cursor_hpos,Y
734: * and that output text will appear there. During updates, the cursor is
735: * supposed to be blinked out and will only reappear after the update
736: * finishes.
737: */
738:
739: CursorToggle ()
740: {
741: register struct matrix *active_screen;
742:
743: if (!WindowMapped) {
744: CursorExists = 0;
745: CursorOutline = 1;
746: return 0;
747: /* Currently the return values are not */
748: /* used, but I could anticipate using */
749: /* them in the future. */
750: }
751:
752: if (VisibleX < 0 || VisibleX >= screen_width ||
753: VisibleY < 0 || VisibleY >= screen_height) {
754: /* Not much can be done */
755: XFlush (XXdisplay);
756: CursorExists = 0;
757: return 0;
758: }
759:
760: active_screen = current_screen;
761:
762: if (active_screen->highlight[VisibleY])
763: /* If the cursor is in the modeline, it means display was preempted.
764: Don't actually display the cursor there, just say we did.
765: The code below doesn't display it right, and nobody wants
766: to see it anyway. */
767: ;
768: else if (active_screen->enable[VisibleY]
769: && VisibleX < active_screen->used[VisibleY]) {
770: if (CursorExists)
771: XDrawImageString(XXdisplay, XXwindow, XXgc_norm,
772: VisibleX*XXfontw+XXInternalBorder,
773: VisibleY*XXfonth+XXInternalBorder+XXbase,
774: (char *) &active_screen->contents[VisibleY][VisibleX],
775: 1);
776: else if (CursorOutline) {
777: XDrawImageString(XXdisplay, XXwindow, XXgc_norm,
778: VisibleX*XXfontw+XXInternalBorder,
779: VisibleY*XXfonth+XXInternalBorder+XXbase,
780: (char *) &active_screen->contents[VisibleY][VisibleX],
781: 1);
782: XDrawRectangle (XXdisplay, XXwindow, XXgc_curs_rev,
783: VisibleX*XXfontw+XXInternalBorder,
784: VisibleY*XXfonth+XXInternalBorder,
785: XXfontw - 1, XXfonth - 1);
786: } else
787: XDrawImageString(XXdisplay, XXwindow, XXgc_curs,
788: VisibleX*XXfontw+XXInternalBorder,
789: VisibleY*XXfonth+XXInternalBorder+XXbase,
790: (char *) &active_screen->contents[VisibleY][VisibleX],
791: 1);
792: }
793: else {
794: if (CursorExists)
795: XClearArea (XXdisplay, XXwindow,
796: VisibleX*XXfontw+XXInternalBorder,
797: VisibleY*XXfonth+XXInternalBorder,
798: XXfontw, XXfonth, 0);
799: else if (CursorOutline)
800: XDrawRectangle (XXdisplay, XXwindow, XXgc_curs_rev,
801: VisibleX*XXfontw+XXInternalBorder,
802: VisibleY*XXfonth+XXInternalBorder,
803: XXfontw - 1, XXfonth - 1);
804: else
805: XDrawImageString(XXdisplay, XXwindow, XXgc_curs,
806: VisibleX*XXfontw+XXInternalBorder,
807: VisibleY*XXfonth+XXInternalBorder+XXbase,
808: " ", 1);
809: }
810:
811: CursorExists = !CursorExists;
812:
813: if (!InUpdate)
814: XFlush (XXdisplay);
815:
816: return 1;
817: }
818:
819: /* This routine is used by routines which are called to paint regions */
820: /* designated by Expose events. If the cursor may be in the exposed */
821: /* region, this routine makes sure it is gone so that dumprectangle can */
822: /* toggle it back into existance if dumprectangle is invoked when not in */
823: /* the midst of a screen update. */
824:
825: static
826: ClearCursor ()
827: {
828: BLOCK_INPUT_DECLARE ();
829:
830: BLOCK_INPUT ();
831: if (!WindowMapped) {
832: CursorExists = 0;
833: CursorOutline = 1;
834: UNBLOCK_INPUT ();
835: return;
836: }
837:
838: if (VisibleX < 0 || VisibleX >= screen_width ||
839: VisibleY < 0 || VisibleY >= screen_height) {
840: /* Not much can be done */
841: CursorExists = 0;
842: UNBLOCK_INPUT ();
843: return;
844: }
845:
846: XClearArea (XXdisplay, XXwindow,
847: VisibleX*XXfontw+XXInternalBorder,
848: VisibleY*XXfonth+XXInternalBorder,
849: XXfontw, XXfonth, 0);
850:
851: CursorExists = 0;
852: UNBLOCK_INPUT ();
853: }
854:
855: XTupdate_begin ()
856: {
857: BLOCK_INPUT_DECLARE ();
858: register int i;
859:
860: #ifdef XDEBUG
861: fprintf (stderr, "XTupdate_begin\n");
862: #endif
863:
864: BLOCK_INPUT ();
865: InUpdate = 1;
866: if (CursorExists)
867: CursorToggle ();
868:
869: for (i=0;i<MAXHEIGHT;i++)
870: updated[i] = 0;
871:
872: SavedX = local_cursor_hpos;
873: SavedY = local_cursor_vpos;
874: /* Thw initial "hardware" cursor position is */
875: /* saved because that is where gnu emacs */
876: /* expects the cursor to be at the end of */
877: /* the update */
878:
879: UNBLOCK_INPUT ();
880: }
881:
882: XTupdate_end ()
883: {
884: BLOCK_INPUT_DECLARE ();
885:
886: #ifdef XDEBUG
887: fprintf (stderr, "XTupdate_end\n");
888: #endif
889:
890: BLOCK_INPUT ();
891: if (CursorExists)
892: CursorToggle ();
893:
894: InUpdate = 0;
895: /* Display cursor at last place requested. */
896: XTmove_cursor (local_cursor_vpos, local_cursor_hpos);
897: XFlush (XXdisplay);
898: UNBLOCK_INPUT ();
899: }
900:
901: /* Used for Expose events. Have to get the text
902: * back into the newly blank areas.
903: */
904:
905: dumprectangle (top, left, rows, cols)
906: register int top, left, rows, cols;
907: {
908: register struct matrix *active_screen;
909: register int ourindex;
910: int localX, localY, localHL;
911:
912: if (top < 0)
913: top = 0;
914: if (left < 0)
915: left = 0;
916: rows += top;
917: cols += left;
918: top /= XXfonth;
919: /* Get row and col containing up and */
920: /* left borders of exposed region -- */
921: /* round down here*/
922: left /= XXfontw;
923: rows += XXfonth-1;
924: cols += XXfontw-1;
925: rows /= XXfonth;
926: /* Get row and col containing bottom and */
927: /* right borders -- round up here */
928: rows -= top;
929: cols /= XXfontw;
930: cols -= left;
931:
932: if (rows < 0)
933: return;
934: if (cols < 0)
935: return;
936: if (top > screen_height - 1)
937: return;
938: if (left > screen_width - 1)
939: return;
940: if (VisibleX >= left && VisibleX < left + cols &&
941: VisibleY >= top && VisibleY < top + rows)
942: ClearCursor ();
943:
944: if (InUpdate)
945: active_screen = new_screen;
946: else
947: /* When queue is dumped in update this */
948: active_screen = current_screen;
949:
950: for (localY = top, ourindex = 0;
951: ourindex < rows && localY < screen_height;
952: ++ourindex, ++localY) {
953: if (localY < 0 || localY >= screen_height ||
954: !active_screen->enable[localY] ||
955: left+1 > active_screen->used[localY])
956: continue;
957: localX = left;
958: localHL = active_screen->highlight[localY];
959: dumpchars (active_screen,
960: min (cols,
961: active_screen->used[localY]-localX),
962: localX, localY, localHL);
963: }
964: if (!InUpdate && !CursorExists)
965: CursorToggle ();
966: /* Routine usually called */
967: /* when not in update */
968: }
969:
970: /* What sections of the window will be modified from the UpdateDisplay
971: * routine is totally under software control. Any line with Y coordinate
972: * greater than flexlines will not change during an update. This is really
973: * used only during dellines and inslines routines (scraplines and stufflines)
974: */
975:
976: XTset_terminal_window (n)
977: register int n;
978: {
979: #ifdef XDEBUG
980: fprintf (stderr, "XTset_terminal_window\n");
981: #endif
982:
983: if (n <= 0 || n > screen_height)
984: flexlines = screen_height;
985: else
986: flexlines = n;
987: }
988:
989: XTins_del_lines (vpos, n)
990: int vpos, n;
991: {
992: #ifdef XDEBUG
993: fprintf (stderr, "XTins_del_lines\n");
994: #endif
995:
996: XTmove_cursor (vpos, 0);
997: if (n >= 0)
998: stufflines (n);
999: else
1000: scraplines (-n);
1001: }
1002:
1003: /* Estimate the cost of scrolling as equal to drawing one fifth
1004: of the character cells copied if black and white,
1005: or half of those characters if color. */
1006:
1007: static
1008: XTcalculate_costs (extra, costvec, ncostvec)
1009: int extra;
1010: int *costvec, *ncostvec;
1011: {
1012: int color_p = DisplayCells (XXdisplay, XXscreen) > 2;
1013:
1014: CalcLID (0, screen_width / (color_p ? 2 : 5), 0, 0, costvec, ncostvec);
1015: }
1016:
1017: static
1018: XTinsert_chars (start, len)
1019: register char *start;
1020: register int len;
1021: {
1022: #ifdef XDEBUG
1023: fprintf (stderr, "XTinsert_chars\n");
1024: #endif
1025:
1026: updateline (0);
1027: }
1028:
1029: static
1030: XTdelete_chars (n)
1031: register int n;
1032: {
1033: char *msg = "Major foobars! This shouldn't show up!";
1034:
1035: #ifdef XDEBUG
1036: fprintf (stderr, "XTdelete_chars (num %d local_cursor_hpos %d)\n",n,local_cursor_hpos);
1037: #endif
1038:
1039: updateline (0);
1040: }
1041:
1042: stufflines (n)
1043: register int n;
1044: {
1045: register int topregion, bottomregion;
1046: register int length, newtop;
1047: BLOCK_INPUT_DECLARE ();
1048:
1049: if (local_cursor_vpos >= flexlines)
1050: return;
1051:
1052: BLOCK_INPUT ();
1053:
1054: if (CursorExists)
1055: CursorToggle ();
1056:
1057: topregion = local_cursor_vpos;
1058: bottomregion = flexlines-(n+1);
1059: newtop = local_cursor_vpos+n;
1060: length = bottomregion-topregion+1;
1061:
1062: if (length > 0 && newtop <= flexlines) {
1063: XCopyArea (XXdisplay, XXwindow, XXwindow, XXgc_norm,
1064: XXInternalBorder,
1065: topregion*XXfonth+XXInternalBorder,
1066: screen_width*XXfontw,
1067: length*XXfonth,
1068: XXInternalBorder, newtop*XXfonth+XXInternalBorder);
1069: }
1070:
1071: newtop = min (newtop, flexlines-1);
1072: length = newtop-topregion;
1073: if (length > 0)
1074: XClearArea (XXdisplay, XXwindow,
1075: XXInternalBorder,
1076: topregion*XXfonth+XXInternalBorder,
1077: screen_width*XXfontw,
1078: n*XXfonth, 0);
1079: UNBLOCK_INPUT ();
1080: }
1081:
1082: scraplines (n)
1083: register int n;
1084: {
1085: BLOCK_INPUT_DECLARE ();
1086:
1087: if (local_cursor_vpos >= flexlines)
1088: return;
1089:
1090: BLOCK_INPUT ();
1091:
1092: if (CursorExists)
1093: CursorToggle ();
1094:
1095: if (local_cursor_vpos+n >= flexlines) {
1096: if (flexlines >= (local_cursor_vpos + 1))
1097: XClearArea (XXdisplay, XXwindow,
1098: XXInternalBorder,
1099: local_cursor_vpos*XXfonth+XXInternalBorder,
1100: screen_width*XXfontw,
1101: (flexlines-local_cursor_vpos) * XXfonth,
1102: 0);
1103: UNBLOCK_INPUT ();
1104: }
1105: else {
1106: XCopyArea (XXdisplay, XXwindow, XXwindow, XXgc_norm,
1107: XXInternalBorder,
1108: (local_cursor_vpos+n)*XXfonth+XXInternalBorder,
1109: screen_width*XXfontw,
1110: (flexlines-local_cursor_vpos-n)*XXfonth,
1111: XXInternalBorder, local_cursor_vpos*XXfonth+XXInternalBorder);
1112:
1113: XClearArea (XXdisplay, XXwindow, XXInternalBorder,
1114: (flexlines-n)*XXfonth+XXInternalBorder,
1115: screen_width*XXfontw,
1116: n*XXfonth, 0);
1117: UNBLOCK_INPUT ();
1118: }
1119: }
1120:
1121: /* Substitutes for standard read routine. Under X not interested in individual
1122: * bytes but rather individual packets.
1123: */
1124:
1125: XTread_socket (sd, bufp, numchars)
1126: register int sd;
1127: register char *bufp;
1128: register int numchars;
1129: {
1130: #ifdef XDEBUG
1131: fprintf(stderr,"XTread_socket\n");
1132: #endif
1133:
1134: return (internal_socket_read (bufp, numchars));
1135: }
1136:
1137: /*
1138: * Interpreting incoming keycodes. Should have table modifiable as needed
1139: * from elisp.
1140: */
1141:
1142: #ifdef sun
1143: char *stringFuncVal(keycode)
1144: KeySym keycode;
1145: {
1146: switch (keycode) {
1147: case XK_L1:
1148: return("192");
1149: case XK_L2:
1150: return("193");
1151: case XK_L3:
1152: return("194");
1153: case XK_L4:
1154: return("195");
1155: case XK_L5:
1156: return("196");
1157: case XK_L6:
1158: return("197");
1159: case XK_L7:
1160: return("198");
1161: case XK_L8:
1162: return("199");
1163: case XK_L9:
1164: return("200");
1165: case XK_L10:
1166: return("201");
1167:
1168: case XK_R1:
1169: return("208");
1170: case XK_R2:
1171: return("209");
1172: case XK_R3:
1173: return("210");
1174: case XK_R4:
1175: return("211");
1176: case XK_R5:
1177: return("212");
1178: case XK_R6:
1179: return("213");
1180: case XK_R7:
1181: return("214");
1182: case XK_R8:
1183: return("215");
1184: case XK_R9:
1185: return("216");
1186: case XK_R10:
1187: return("217");
1188: case XK_R11:
1189: return("218");
1190: case XK_R12:
1191: return("219");
1192: case XK_R13:
1193: return("220");
1194: case XK_R14:
1195: return("221");
1196: case XK_R15:
1197: return("222");
1198:
1199: case XK_Break: /* Sun3 "Alternate" key */
1200: return("223");
1201:
1202: case XK_F1:
1203: return("224");
1204: case XK_F2:
1205: return("225");
1206: case XK_F3:
1207: return("226");
1208: case XK_F4:
1209: return("227");
1210: case XK_F5:
1211: return("228");
1212: case XK_F6:
1213: return("229");
1214: case XK_F7:
1215: return("230");
1216: case XK_F8:
1217: return("231");
1218: case XK_F9:
1219: return("232");
1220: case XK_F10:
1221: return("233");
1222:
1223: default:
1224: return("-1");
1225: }
1226: }
1227: #else
1228: #ifndef AIX
1229: char *stringFuncVal(keycode)
1230: KeySym keycode;
1231: {
1232: switch (keycode) {
1233: case XK_F1:
1234: return("11");
1235: case XK_F2:
1236: return("12");
1237: case XK_F3:
1238: return("13");
1239: case XK_F4:
1240: return("14");
1241: case XK_F5:
1242: return("15");
1243: case XK_F6:
1244: return("17");
1245: case XK_F7:
1246: return("18");
1247: case XK_F8:
1248: return("19");
1249: case XK_F9:
1250: return("20");
1251: case XK_F10:
1252: return("21");
1253: case XK_F11:
1254: return("23");
1255: case XK_F12:
1256: return("24");
1257: case XK_F13:
1258: return("25");
1259: case XK_F14:
1260: return("26");
1261: case XK_F15:
1262: return("28");
1263: case XK_Help:
1264: return("28");
1265: case XK_F16:
1266: return("29");
1267: case XK_Menu:
1268: return("29");
1269: case XK_F17:
1270: return("31");
1271: case XK_F18:
1272: return("32");
1273: case XK_F19:
1274: return("33");
1275: case XK_F20:
1276: return("34");
1277:
1278: case XK_Find :
1279: return("1");
1280: case XK_Insert:
1281: return("2");
1282: case XK_Delete:
1283: return("3");
1284: case XK_Select:
1285: return("4");
1286: case XK_Prior:
1287: return("5");
1288: case XK_Next:
1289: return("6");
1290: default:
1291: return("-1");
1292: }
1293: }
1294: #endif /* not AIX */
1295: #endif /* not sun */
1296:
1297: internal_socket_read(bufp, numchars)
1298: register unsigned char *bufp;
1299: register int numchars;
1300: {
1301: /* Number of keyboard chars we have produced so far. */
1302: int count = 0;
1303: int nbytes;
1304: char mapping_buf[20];
1305: BLOCK_INPUT_DECLARE ();
1306: XEvent event;
1307: /* Must be static since data is saved between calls. */
1308: static XComposeStatus status;
1309: KeySym keysym;
1310: SIGMASKTYPE oldmask;
1311:
1312: BLOCK_INPUT ();
1313: #ifdef BSD
1314: #ifndef BSD4_1
1315: oldmask = sigblock (sigmask (SIGALRM));
1316: #endif
1317: #endif
1318: #ifdef FIOSNBIO
1319: /* If available, Xlib uses FIOSNBIO to make the socket
1320: non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set, FIOSNBIO is
1321: ignored, and instead of signalling EWOULDBLOCK, a read returns
1322: 0, which Xlib interprets as equivalent to EPIPE. */
1323: fcntl (fileno (stdin), F_SETFL, 0);
1324: #endif
1325: #ifndef HAVE_SELECT
1326: if (! (fcntl (fileno (stdin), F_GETFL, 0) & O_NDELAY))
1327: {
1328: extern int read_alarm_should_throw;
1329: read_alarm_should_throw = 1;
1330: XPeekEvent (XXdisplay,&event);
1331: read_alarm_should_throw = 0;
1332: }
1333: #endif
1334: while (XPending (XXdisplay)) {
1335: XNextEvent (XXdisplay,&event);
1336: event.type &= 0177; /* Mask out XSendEvent indication */
1337:
1338: switch (event.type) {
1339:
1340: default:
1341: break;
1342:
1343: case MappingNotify:
1344: XRefreshKeyboardMapping(&event.xmapping);
1345: break;
1346:
1347: case MapNotify:
1348: WindowMapped = 1;
1349: break;
1350:
1351: case UnmapNotify:
1352: WindowMapped = 0;
1353: break;
1354:
1355: case ConfigureNotify:
1356: if (abs(pixelheight-event.xconfigure.height) >= XXfonth
1357: || abs(pixelwidth-event.xconfigure.width) >= XXfontw)
1358: {
1359: int rows, cols;
1360:
1361: rows = (event.xconfigure.height-2*XXInternalBorder)/XXfonth;
1362: cols = (event.xconfigure.width-2*XXInternalBorder)/XXfontw;
1363: pixelwidth = cols*XXfontw+2*XXInternalBorder;
1364: pixelheight = rows*XXfonth+2*XXInternalBorder;
1365:
1366: /* This is absolutely, amazingly gross. However, without
1367: it, emacs will core dump if the window gets too small.
1368: And uwm is too brain-damaged to handle large minimum size
1369: windows. */
1370: if (cols > 11 && rows > 4)
1371: /* Delay the change unless Emacs is waiting for input. */
1372: change_screen_size (rows, cols, 0, !waiting_for_input, 1);
1373: }
1374: break;
1375:
1376: case Expose:
1377: if (!delayed_size_change)
1378: dumprectangle (event.xexpose.y-XXInternalBorder,
1379: event.xexpose.x-XXInternalBorder,
1380: event.xexpose.height,
1381: event.xexpose.width);
1382: break;
1383:
1384: case GraphicsExpose:
1385: if (!delayed_size_change)
1386: dumprectangle (event.xgraphicsexpose.y-XXInternalBorder,
1387: event.xgraphicsexpose.x-XXInternalBorder,
1388: event.xgraphicsexpose.height,
1389: event.xgraphicsexpose.width);
1390: break;
1391:
1392: case NoExpose:
1393: break;
1394:
1395: #if 0
1396: case FocusIn:
1397: case FocusOut:
1398: case EnterNotify:
1399: case LeaveNotify:
1400: {
1401: int cursor = -1; /* 0=on, 1=off, -1=no change */
1402:
1403: if (event.type == FocusIn) cursor = 0;
1404: else if (event.type == FocusOut) cursor = 1;
1405: else
1406: {
1407: Window focus;
1408: int revert_to; /* dummy return val */
1409: XGetInputFocus (XXdisplay, &focus, &revert_to);
1410: if (focus == PointerRoot)
1411: cursor = (event.type == LeaveNotify) ? 1 : 0;
1412: }
1413: if (cursor == -1) break;
1414: CursorToggle();
1415: CursorOutline = cursor;
1416: CursorToggle();
1417: }
1418: #endif
1419: case FocusIn:
1420: /* [email protected] says adding the following line fixes the
1421: problems with grabbing and twm. */
1422: if (event.xfocus.mode == NotifyNormal)
1423: x_focus_flag = 1;
1424: case EnterNotify:
1425: if (event.type == FocusIn || (!x_focus_flag && event.xcrossing.focus))
1426: {
1427: CursorToggle ();
1428: CursorOutline = 0;
1429: CursorToggle ();
1430: }
1431: break;
1432:
1433: case FocusOut:
1434: x_focus_flag = 0;
1435: case LeaveNotify:
1436: if (event.type == FocusOut || (!x_focus_flag && event.xcrossing.focus))
1437: {
1438: CursorToggle ();
1439: CursorOutline = 1;
1440: CursorToggle ();
1441: }
1442: break;
1443:
1444: case KeyPress:
1445: nbytes = XLookupString (&event.xkey,
1446: mapping_buf, 20, &keysym,
1447: 0);
1448:
1449: #ifndef AIX
1450: /* Someday this will be unnecessary as we will
1451: be able to use XRebindKeysym so XLookupString
1452: will have already given us the string we want. */
1453: if (IsFunctionKey(keysym)
1454: || IsMiscFunctionKey(keysym)
1455: || keysym == XK_Prior
1456: || keysym == XK_Next) {
1457: strcpy(mapping_buf,"[");
1458: strcat(mapping_buf,stringFuncVal(keysym));
1459: #ifdef sun
1460: strcat(mapping_buf,"z");
1461: #else
1462: strcat(mapping_buf,"~");
1463: #endif /* sun */
1464: nbytes = strlen(mapping_buf);
1465: }
1466: else {
1467: #endif /* not AIX */
1468: switch (keysym) {
1469: case XK_Left:
1470: strcpy(mapping_buf,"\002");
1471: nbytes = 1;
1472: break;
1473: case XK_Right:
1474: strcpy(mapping_buf,"\006");
1475: nbytes = 1;
1476: break;
1477: case XK_Up:
1478: strcpy(mapping_buf,"\020");
1479: nbytes = 1;
1480: break;
1481: case XK_Down:
1482: strcpy(mapping_buf,"\016");
1483: nbytes = 1;
1484: break;
1485: }
1486: #ifndef AIX
1487: }
1488: #endif /* not AIX */
1489: if (nbytes) {
1490: if ((nbytes == 1) && (event.xkey.state & Mod1Mask))
1491: *mapping_buf |= METABIT;
1492: if ((nbytes == 1) && (event.xkey.state & ControlMask))
1493: *mapping_buf &= 0x9F; /* mask off bits 1 and 2 */
1494: if (numchars-nbytes > 0) {
1495: bcopy (mapping_buf, bufp, nbytes);
1496: bufp += nbytes;
1497: count += nbytes;
1498: numchars -= nbytes;
1499: }
1500: }
1501: break;
1502:
1503: case ButtonPress:
1504: case ButtonRelease:
1505: *bufp++ = (char) 'X' & 037;
1506: ++count;
1507: --numchars;
1508: *bufp++ = (char) '@' & 037;
1509: ++count;
1510: --numchars;
1511: if (XXm_queue_num == XMOUSEBUFSIZE)
1512: break;
1513: XXm_queue[XXm_queue_in] = (XEvent *) malloc (sizeof(XEvent));
1514: *XXm_queue[XXm_queue_in] = event;
1515: XXm_queue_num++;
1516: XXm_queue_in = (XXm_queue_in + 1) % XMOUSEBUFSIZE;
1517: break;
1518: }
1519: }
1520:
1521: if (CursorExists)
1522: xfixscreen ();
1523:
1524: #ifdef BSD
1525: #ifndef BSD4_1
1526: sigsetmask (oldmask);
1527: #endif
1528: #endif
1529: UNBLOCK_INPUT ();
1530: return count;
1531: }
1532:
1533: /* Exit gracefully from gnuemacs, doing an autosave and giving a status.
1534: */
1535:
1536: XExitGracefully ()
1537: {
1538: XCleanUp();
1539: exit (70);
1540: }
1541:
1542: XIgnoreError ()
1543: {
1544: return 0;
1545: }
1546:
1547: static int server_ping_timer;
1548:
1549: xfixscreen ()
1550: {
1551: BLOCK_INPUT_DECLARE ();
1552:
1553: if (server_ping_timer > 0)
1554: server_ping_timer--;
1555: else
1556: {
1557: server_ping_timer = 100;
1558:
1559: /* Yes, this is really what I mean -- Check to see if we've
1560: * lost our connection */
1561:
1562: BLOCK_INPUT ();
1563: XSetErrorHandler(0);
1564: XSetIOErrorHandler(0);
1565: XNoOp (XXdisplay);
1566: XFlush (XXdisplay);
1567: XSetErrorHandler(handler);
1568: XSetIOErrorHandler(handler);
1569: if (!InUpdate && !CursorExists)
1570: CursorToggle ();
1571:
1572: UNBLOCK_INPUT ();
1573: }
1574: }
1575:
1576:
1577: /* ------------------------------------------------------------
1578: */
1579: static int reversevideo;
1580:
1581: static int
1582: XT_GetDefaults (class)
1583: char *class;
1584: {
1585: register struct _xdeftab *entry;
1586: char *iname, *cname;
1587:
1588: char *disp = 0, *scrn = 0;
1589:
1590: int len = strlen (CLASS);
1591: if (strlen (class) > len)
1592: len = strlen (class);
1593:
1594: /* 100 is bigger than any of the resource names in our fixed set. */
1595: iname = (char *) alloca (len + 100);
1596: cname = (char *) alloca (len + 100);
1597:
1598: XrmInitialize ();
1599:
1600: /* Merge all databases on root window. */
1601:
1602: disp = XResourceManagerString (XXdisplay);
1603: if (disp) db = XrmGetStringDatabase (disp);
1604:
1605: #if (XlibSpecificationRelease >= 5)
1606: scrn = XScreenResourceString (ScreenOfDisplay (XXdisplay, XXscreen));
1607: if (scrn) db2 = XrmGetStringDatabase (scrn);
1608:
1609: /* Screen database takes precedence over global database. */
1610: XrmMergeDatabases (db2, &db);
1611: #endif
1612:
1613: /*
1614: * Walk the table reading in the resources. Instance names supersede
1615: * class names.
1616: */
1617:
1618: for (entry = xDefaultsValueTable; entry->iname; entry++)
1619: {
1620: /* Build the instance name and class name of resource. */
1621: XrmValue value;
1622: char *dummy;
1623: register char *option;
1624:
1625: strcpy (iname, class);
1626: strcat (iname, ".");
1627: strcat (iname, entry->iname);
1628: strcpy (cname, CLASS);
1629: strcat (cname, ".");
1630: strcat (cname, entry->cname);
1631:
1632: if (XrmGetResource (db, iname, cname, &dummy, &value))
1633: {
1634: if (entry->varp)
1635: *entry->varp = (char*)value.addr;
1636: }
1637: else
1638: {
1639: #ifdef XBACKWARDS
1640: if (!(option = XGetDefault (XXdisplay, entry->iname, class)))
1641: if (!(option = XGetDefault (XXdisplay, entry->iname, CLASS)))
1642: if (!(option = XGetDefault (XXdisplay, entry->cname, class)))
1643: option = XGetDefault (XXdisplay, entry->cname, CLASS);
1644: #else
1645: if (!(option = XGetDefault (XXdisplay, class, entry->iname)))
1646: if (!(option = XGetDefault (XXdisplay, CLASS, entry->iname)))
1647: if (!(option = XGetDefault (XXdisplay, class, entry->cname)))
1648: option = XGetDefault (XXdisplay, CLASS, entry->cname);
1649: #endif
1650: if (option && entry->varp)
1651: *entry->varp = option;
1652: }
1653: }
1654:
1655: /*
1656: * Now set global variables that aren't character strings; yes it would
1657: * be nice to do this automatically as part of the scanning step, but this
1658: * is less likely to screw up. The real answer is to use the resource
1659: * manager.
1660: */
1661:
1662: if (temp_reverseVideo)
1663: {
1664: if (strcmp (temp_reverseVideo, "on") == 0)
1665: reversevideo = 1;
1666: else if (strcmp (temp_reverseVideo, "off") == 0)
1667: reversevideo = 0;
1668: }
1669:
1670: if (temp_borderWidth)
1671: XXborder = atoi (temp_borderWidth);
1672:
1673: if (temp_internalBorder)
1674: XXInternalBorder = atoi (temp_internalBorder);
1675:
1676: if (temp_useBitmap)
1677: {
1678: if (strcmp (temp_useBitmap, "on") == 0)
1679: XXicon_usebitmap = 1;
1680: else if (strcmp (temp_useBitmap, "off") == 0)
1681: XXicon_usebitmap = 0;
1682: }
1683:
1684: return 0;
1685: }
1686:
1687: x_error_handler (disp, event)
1688: Display *disp;
1689: XErrorEvent *event;
1690: {
1691: char msg[200];
1692: XGetErrorText (disp, event->error_code, msg, 200);
1693: fprintf (stderr, "Fatal X-windows error: %s\n", msg);
1694: Fkill_emacs (make_number (70));
1695: }
1696:
1697: x_io_error_handler ()
1698: {
1699: int save_errno = errno;
1700: if (errno == EPIPE)
1701: kill (0, SIGHUP);
1702: Fdo_auto_save ();
1703: errno = save_errno;
1704: perror ("Fatal X-windows I/O error");
1705: kill (0, SIGILL);
1706: }
1707:
1708: x_term_init ()
1709: {
1710: register char *vardisplay;
1711: register int xxargc;
1712: register char **xxargv;
1713: char *ptr;
1714: XColor cdef;
1715:
1716: extern char *getenv ();
1717: extern XTinterrupt_signal ();
1718: extern char *malloc ();
1719: extern Lisp_Object Vxterm, Vxterm1, Qt;
1720: extern int XIgnoreError();
1721: int ix;
1722:
1723:
1724: vardisplay = (alternate_display ? alternate_display : "");
1725: if (!vardisplay) {
1726: fprintf (stderr, "DISPLAY environment variable must be set\n");
1727: exit (-200);
1728: }
1729:
1730: XXdisplay = XOpenDisplay (vardisplay);
1731: if (XXdisplay == (Display *) 0) {
1732: fprintf (stderr, "X server not responding. Check your DISPLAY environment variable.\n");
1733: exit (-99);
1734: }
1735:
1736: XXscreen = DefaultScreen (XXdisplay);
1737: XXisColor = DisplayCells (XXdisplay, XXscreen) > 2;
1738: XXColorMap = DefaultColormap (XXdisplay, XXscreen);
1739:
1740: XSetErrorHandler (x_error_handler);
1741: XSetIOErrorHandler (x_io_error_handler);
1742: signal (SIGPIPE, x_io_error_handler);
1743:
1744: WindowMapped = 0;
1745: baud_rate = 9600;
1746: min_padding_speed = 10000;
1747: must_write_spaces = 1;
1748: meta_key = 1;
1749: visible_bell = 1;
1750: inverse_video = 0;
1751:
1752: fix_screen_hook = xfixscreen;
1753: clear_screen_hook = XTclear_screen;
1754: clear_end_of_line_hook = XTclear_end_of_line;
1755: ins_del_lines_hook = XTins_del_lines;
1756: change_line_highlight_hook = XTchange_line_highlight;
1757: insert_chars_hook = XTinsert_chars;
1758: output_chars_hook = XToutput_chars;
1759: delete_chars_hook = XTdelete_chars;
1760: ring_bell_hook = XTfeep;
1761: reset_terminal_modes_hook = XTreset_terminal_modes;
1762: set_terminal_modes_hook = XTset_terminal_modes;
1763: update_begin_hook = XTupdate_begin;
1764: update_end_hook = XTupdate_end;
1765: set_terminal_window_hook = XTset_terminal_window;
1766: read_socket_hook = XTread_socket;
1767: move_cursor_hook = XTmove_cursor;
1768: reassert_line_highlight_hook = XTreassert_line_highlight;
1769: scroll_region_ok = 1; /* we'll scroll partial screens */
1770: char_ins_del_ok = 0;
1771: line_ins_del_ok = 1; /* we'll just blt 'em */
1772: fast_clear_end_of_line = 1; /* X does this well */
1773: memory_below_screen = 0; /* we don't remember what scrolls
1774: * off the bottom */
1775: dont_calculate_costs = 1;
1776: calculate_costs_hook = XTcalculate_costs;
1777:
1778: /* New options section */
1779: XXborder = 1;
1780: XXInternalBorder = 1;
1781: screen_width = 80;
1782: screen_height = 66;
1783:
1784: reversevideo = 0;
1785:
1786: XXdebug = 0;
1787: XXm_queue_num = 0;
1788: XXm_queue_in = 0;
1789: XXm_queue_out = 0;
1790:
1791: #if 0
1792: handler = XIgnoreError;
1793: XSetErrorHandler (handler);
1794: XSetIOErrorHandler (handler);
1795: #endif
1796:
1797: desiredwindow =
1798: XXcurrentfont =
1799: XXidentity =
1800: XXicon_name =
1801: XXheader = (char *) NULL;
1802:
1803: XXicon_usebitmap = 0;
1804:
1805: #ifdef X_DEFAULT_FONT
1806: temp_font = X_DEFAULT_FONT;
1807: #else
1808: temp_font = "fixed";
1809: #endif
1810: progname = xargv[0];
1811: if (ptr = rindex(progname, '/'))
1812: progname = ptr+1;
1813: XXpid = getpid ();
1814: default_window = "=80x24+0+0";
1815:
1816: #if 0
1817: handler = XIgnoreError;
1818: XSetErrorHandler (handler);
1819: XSetIOErrorHandler (handler);
1820: #endif
1821:
1822: /* Get resource name and its defaults, it it exists...
1823: */
1824: for (ix = 1; ix < xargc && xargv[ix][0] == '-'; ix++)
1825: {
1826: int valx;
1827:
1828: if (strcmp(xargv[ix], "-rn") == 0 &&
1829: (valx = ix + 1) < xargc)
1830: {
1831: XXidentity = (char *) xmalloc (strlen(xargv[valx]) + 1 );
1832: (void) strcpy(XXidentity, xargv[valx]);
1833:
1834: break;
1835: }
1836: }
1837:
1838: if (!XXidentity)
1839: {
1840: char *t;
1841:
1842: if ( (t = getenv("WM_RES_NAME")) != (char *) NULL )
1843: XXidentity = t;
1844:
1845: if (!XXidentity)
1846: {
1847: XXidentity = progname;
1848: }
1849: }
1850:
1851: if (XXidentity)
1852: XT_GetDefaults(XXidentity);
1853: else
1854: XT_GetDefaults(CLASS);
1855:
1856: XXpid = getpid ();
1857: default_window = "=80x24+0+0";
1858:
1859: /* Process X command line args...*/
1860: xxargc = xargc;
1861: xxargv = xargv;
1862: xxargv++;
1863: xxargc--;
1864: while (xxargc) {
1865: int sargc;
1866: sargc = xxargc;
1867: if (xxargc && !strcmp (*xxargv, "-r")) {
1868: reversevideo = !reversevideo;
1869: xxargc--;
1870: xxargv++;
1871: }
1872: if ((xxargc > 1) && (!strcmp (*xxargv, "-font") ||
1873: !strcmp (*xxargv, "-fn"))) {
1874: xxargc--;
1875: xxargv++;
1876: if (XXcurrentfont != NULL)
1877: free(XXcurrentfont);
1878: XXcurrentfont = (char *) xmalloc (strlen (*xxargv)+1);
1879: strcpy (XXcurrentfont, *xxargv);
1880: xxargc--;
1881: xxargv++;
1882: }
1883: if ((xxargc > 1) && !strcmp (*xxargv, "-wn")) {
1884: xxargc--;
1885: xxargv++;
1886: XXheader = (char *) xmalloc (strlen (*xxargv)+1);
1887: strcpy (XXheader, *xxargv);
1888: xxargc--;
1889: xxargv++;
1890: }
1891: if ((xxargc > 1) && !strcmp (*xxargv, "-in")) {
1892: xxargc--;
1893: xxargv++;
1894: XXicon_name = (char *) xmalloc (strlen (*xxargv)+1);
1895: strcpy (XXicon_name, *xxargv);
1896: xxargc--;
1897: xxargv++;
1898: }
1899: if (xxargc && !strcmp (*xxargv, "-i")) {
1900: xxargc--;
1901: xxargv++;
1902: XXicon_usebitmap = 1;
1903: }
1904: if ((xxargc > 1) && !strcmp (*xxargv, "-b")) {
1905: xxargc--;
1906: xxargv++;
1907: XXborder = atoi (*xxargv);
1908: xxargc--;
1909: xxargv++;
1910: }
1911: if ((xxargc > 1) && !strcmp (*xxargv, "-ib")) {
1912: xxargc--;
1913: xxargv++;
1914: XXInternalBorder = atoi (*xxargv);
1915: xxargc--;
1916: xxargv++;
1917: }
1918: if ((xxargc > 1) && (!strcmp (*xxargv, "-w") ||
1919: !strcmp (*xxargv, "-geometry"))) {
1920: xxargc--;
1921: xxargv++;
1922: desiredwindow = (char *) xmalloc (strlen (*xxargv)+1);
1923: strcpy (desiredwindow, *xxargv);
1924: xxargc--;
1925: xxargv++;
1926: }
1927: if (XXisColor) {
1928: if ((xxargc > 1 && !strcmp (*xxargv, "-fg"))) {
1929: xxargc--;
1930: xxargv++;
1931:
1932: fore_color =
1933: (char *) xmalloc (strlen (*xxargv)+1);
1934: strcpy (fore_color, *xxargv);
1935:
1936: xxargc--;
1937: xxargv++;
1938: }
1939: if ((xxargc > 1 && !strcmp (*xxargv, "-bg"))) {
1940: xxargc--;
1941: xxargv++;
1942:
1943: back_color =
1944: (char *) xmalloc (strlen (*xxargv)+1);
1945: strcpy (back_color, *xxargv);
1946:
1947: xxargc--;
1948: xxargv++;
1949: }
1950: if ((xxargc > 1 && !strcmp (*xxargv, "-bd"))) {
1951: xxargc--;
1952: xxargv++;
1953:
1954: brdr_color =
1955: (char *) xmalloc (strlen (*xxargv)+1);
1956: strcpy (brdr_color, *xxargv);
1957:
1958: xxargc--;
1959: xxargv++;
1960: }
1961: if ((xxargc > 1 && !strcmp (*xxargv, "-cr"))) {
1962: xxargc--;
1963: xxargv++;
1964:
1965: curs_color =
1966: (char *) xmalloc (strlen (*xxargv)+1);
1967: strcpy (curs_color, *xxargv);
1968:
1969: xxargc--;
1970: xxargv++;
1971: }
1972: if ((xxargc > 1 && !strcmp (*xxargv, "-ms"))) {
1973: xxargc--;
1974: xxargv++;
1975:
1976: mous_color =
1977: (char *) xmalloc (strlen (*xxargv)+1);
1978: strcpy (mous_color, *xxargv);
1979:
1980: xxargc--;
1981: xxargv++;
1982: }
1983: }
1984: if (sargc == xxargc) {
1985: xxargc--;
1986: xxargv++;
1987: }
1988: }
1989:
1990: /* Now, actually Parse and Set colors...
1991: */
1992: if (XXisColor) {
1993: if (fore_color || back_color)
1994: reversevideo = 0;
1995: if (fore_color &&
1996: XParseColor (XXdisplay, XXColorMap, fore_color, &cdef) &&
1997: XAllocColor (XXdisplay, XXColorMap, &cdef))
1998: fore = cdef.pixel;
1999: else {
2000: fore_color = black_color;
2001: fore = BlackPixel (XXdisplay, XXscreen);
2002: }
2003:
2004: if (back_color &&
2005: XParseColor (XXdisplay, XXColorMap, back_color, &cdef) &&
2006: XAllocColor (XXdisplay, XXColorMap, &cdef))
2007: back = cdef.pixel;
2008: else {
2009: back_color = white_color;
2010: back = WhitePixel (XXdisplay, XXscreen);
2011: }
2012:
2013: if (curs_color &&
2014: XParseColor (XXdisplay, XXColorMap, curs_color, &cdef) &&
2015: XAllocColor (XXdisplay, XXColorMap, &cdef))
2016: curs = cdef.pixel;
2017: else {
2018: curs_color = black_color;
2019: curs = BlackPixel (XXdisplay, XXscreen);
2020: }
2021:
2022: if (mous_color &&
2023: XParseColor (XXdisplay, XXColorMap, mous_color, &cdef) &&
2024: XAllocColor (XXdisplay, XXColorMap, &cdef))
2025: ;
2026: else mous_color = black_color;
2027:
2028: if (brdr_color &&
2029: XParseColor (XXdisplay, XXColorMap, brdr_color, &cdef) &&
2030: XAllocColor (XXdisplay, XXColorMap, &cdef))
2031: brdr = cdef.pixel;
2032: else {
2033: brdr_color = black_color;
2034: brdr = BlackPixel (XXdisplay, XXscreen);
2035: }
2036: }
2037: else {
2038: fore_color = curs_color = mous_color = brdr_color
2039: = black_color;
2040: fore = curs = brdr = BlackPixel (XXdisplay, XXscreen);
2041: back_color = white_color;
2042: back = WhitePixel (XXdisplay, XXscreen);
2043: }
2044:
2045:
2046: if (reversevideo) {
2047: int tempcolor;
2048: char *tempname;
2049: brdr = back;
2050: brdr_color = back_color;
2051: tempcolor = fore;
2052: fore = back;
2053: back = tempcolor;
2054: tempname = fore_color;
2055: fore_color = back_color;
2056: back_color = tempname;
2057: if (!strcmp (mous_color, back_color))
2058: mous_color = fore_color;
2059: else if (!strcmp (mous_color, fore_color))
2060: mous_color = back_color;
2061: if (!strcmp (curs_color, back_color))
2062: curs_color = fore_color, curs = fore;
2063: else if (!strcmp (curs_color, fore_color))
2064: curs_color = back_color, curs = back;
2065: }
2066:
2067:
2068: if (!XXcurrentfont)
2069: {
2070: XXcurrentfont = (char *) xmalloc (strlen (temp_font) + 1);
2071:
2072: if (!XXcurrentfont) {
2073: fprintf (stderr, "Memory allocation failure.\n");
2074: exit (-150);
2075: }
2076:
2077: strcpy (XXcurrentfont, temp_font);
2078: }
2079:
2080:
2081:
2082: signal (SIGPIPE, XExitGracefully);
2083:
2084: #ifndef CANNOT_DUMP
2085: if (initialized)
2086: #endif /* CANNOT_DUMP */
2087: Vxterm = Qt;
2088:
2089: Fset (intern ("window-system-version"), make_number (11));
2090:
2091: XInitWindow ();
2092:
2093: keyboard_init_hook = x_init_1;
2094: }
2095:
2096: /* Initialize for keyboard input using X.
2097: This is called by init_keyboard via keyboard_init_hook. */
2098:
2099: static void
2100: x_init_1 ()
2101: {
2102: #ifdef F_SETOWN
2103: extern int old_fcntl_owner;
2104: #endif
2105:
2106: dup2 (ConnectionNumber(XXdisplay), 0);
2107: #ifndef SYSV_STREAMS
2108: /* Streams somehow keeps track of which descriptor number
2109: is being used to talk to X. So it is not safe to substitute
2110: descriptor 0. But it is safe to make descriptor 0 a copy of it. */
2111: close (ConnectionNumber(XXdisplay));
2112: ConnectionNumber(XXdisplay) = 0; /* Looks a little strange?
2113: * check the def of the macro;
2114: * it is a genuine lvalue */
2115: #endif
2116:
2117: #ifdef USG
2118: setpgrp (); /* No arguments but equivalent in this case */
2119: #else
2120: setpgrp (0, getpid ());
2121: #endif /* USG */
2122:
2123: #ifdef F_SETOWN
2124: old_fcntl_owner = fcntl (0, F_GETOWN, 0);
2125: #ifdef F_SETOWN_SOCK_NEG
2126: fcntl (0, F_SETOWN, -getpid ()); /* stdin is a socket here */
2127: #else
2128: fcntl (0, F_SETOWN, getpid ());
2129: #endif /* F_SETOWN_SOCK_NEG */
2130: #endif /* F_SETOWN */
2131:
2132: /* Enable interrupt_input because otherwise we cannot asynchronously
2133: detect C-g sent as a keystroke event from the X server. */
2134: Fset_input_mode (Qt, Qnil, Qnil);
2135: }
2136:
2137: XSetFlash ()
2138: {
2139: ring_bell_hook = XTflash;
2140: }
2141:
2142: XSetFeep ()
2143: {
2144: ring_bell_hook = XTfeep;
2145: }
2146:
2147:
2148: /* ------------------------------------------------------------
2149: * Load a font by name. Return the font pointer, or NULL if
2150: * it can't be loaded. Do all appropriate calculations.
2151: */
2152: static XFontStruct *
2153: XT_CalcForFont(fontname)
2154: char *fontname;
2155: {
2156: XFontStruct *fontp;
2157:
2158:
2159: if ( (fontp = XLoadQueryFont(XXdisplay, fontname)) == (XFontStruct *) 0 )
2160: {
2161: return (XFontStruct *) NULL;
2162: }
2163:
2164: XXfid = fontp->fid;
2165: XXfonth = fontp->ascent + fontp->descent;
2166: XXfontw = fontp->max_bounds.width;
2167: XXbase = fontp->ascent;
2168:
2169: return fontp;
2170: }
2171:
2172:
2173: /* ------------------------------------------------------------
2174: */
2175: XNewFont (newname)
2176: register char *newname;
2177: {
2178: XFontStruct *temp;
2179: BLOCK_INPUT_DECLARE ();
2180:
2181: BLOCK_INPUT ();
2182: XFlush (XXdisplay);
2183:
2184:
2185: temp = XT_CalcForFont(newname);
2186:
2187: if (temp == (XFontStruct *) NULL)
2188: {
2189: UNBLOCK_INPUT ();
2190: return -1;
2191: }
2192:
2193: XSetFont (XXdisplay, XXgc_norm, XXfid);
2194: XSetFont (XXdisplay, XXgc_rev, XXfid);
2195: XSetFont (XXdisplay, XXgc_curs, XXfid);
2196: XSetFont (XXdisplay, XXgc_curs_rev, XXfid);
2197:
2198: XFreeFont (XXdisplay, fontinfo);
2199: fontinfo = temp;
2200:
2201:
2202: XSetWindowSize(screen_height, screen_width);
2203:
2204:
2205: UNBLOCK_INPUT ();
2206: return 0;
2207: }
2208:
2209: /* Flip foreground/background colors */
2210:
2211: XFlipColor ()
2212: {
2213: int tempcolor;
2214: char *tempname;
2215: XColor forec, backc;
2216: BLOCK_INPUT_DECLARE ();
2217:
2218: BLOCK_INPUT ();
2219: CursorToggle ();
2220: XSetWindowBackground(XXdisplay, XXwindow, fore);
2221: if (XXborder)
2222: XSetWindowBorder(XXdisplay, XXwindow, back);
2223:
2224: brdr = back;
2225: brdr_color = back_color;
2226: tempcolor = fore;
2227: fore = back;
2228: back = tempcolor;
2229: tempname = fore_color;
2230: fore_color = back_color;
2231: back_color = tempname;
2232: XClearArea (XXdisplay, XXwindow, 0, 0,
2233: screen_width*XXfontw+2*XXInternalBorder,
2234: screen_height*XXfonth+2*XXInternalBorder, 0);
2235:
2236: XXgc_temp = XXgc_norm;
2237: XXgc_norm = XXgc_rev;
2238: XXgc_rev = XXgc_temp;
2239:
2240: if (!strcmp (mous_color, back_color))
2241: mous_color = fore_color;
2242: else if (!strcmp (mous_color, fore_color))
2243: mous_color = back_color;
2244:
2245: x_set_cursor_colors ();
2246:
2247: XRedrawDisplay ();
2248: if (!strcmp (curs_color, back_color))
2249: curs_color = fore_color, curs = fore;
2250: else if (!strcmp (curs_color, fore_color))
2251: curs_color = back_color, curs = back;
2252:
2253: XSetState (XXdisplay, XXgc_curs, back, curs, GXcopy, AllPlanes);
2254: XSetState (XXdisplay, XXgc_curs_rev, curs, back, GXcopy, AllPlanes);
2255:
2256: CursorToggle ();
2257: XFlush (XXdisplay);
2258: UNBLOCK_INPUT ();
2259: }
2260:
2261: /* ------------------------------------------------------------
2262: */
2263:
2264: #define NO_MANAGER 1
2265:
2266:
2267: /* ------------------------------------------------------------
2268: */
2269: static XClassHint class_hint;
2270:
2271:
2272: static int
2273: XT_Set_Class_Hints(w)
2274: Window w;
2275: {
2276: extern char *getenv();
2277:
2278:
2279: if (XXidentity == (char *) NULL)
2280: XXidentity = ""; /* XSCH() doesn't like NULL pointers! */
2281:
2282: class_hint.res_name = XXidentity;
2283: class_hint.res_class = CLASS;
2284:
2285:
2286: XSetClassHint(XXdisplay, w, &class_hint);
2287: }
2288:
2289:
2290: /* ------------------------------------------------------------
2291: */
2292: static int
2293: XT_Set_Command_Line(w)
2294: Window w;
2295: {
2296:
2297: XSetCommand(XXdisplay, w, xargv, xargc);
2298: }
2299:
2300:
2301: /* ------------------------------------------------------------
2302: */
2303: static char hostname[100];
2304:
2305: static int
2306: XT_Set_Host(w)
2307: Window w;
2308: {
2309:
2310: gethostname(hostname, 100);
2311: hostname[99] = '\0';
2312:
2313: XChangeProperty(XXdisplay, w, XA_WM_CLIENT_MACHINE, XA_STRING, 8,
2314: PropModeReplace,
2315: (unsigned char *) hostname, strlen(hostname));
2316: }
2317:
2318:
2319: /* ------------------------------------------------------------
2320: * Set header title to window-name (from '-wn'), or if none,
2321: * "optional-id: class-of-appl @ host"
2322: */
2323: static int
2324: XT_Set_Title(w)
2325: Window w;
2326: {
2327: char header_info[200];
2328:
2329:
2330: if (XXheader != (char *) NULL)
2331: {
2332: strcpy(header_info, XXheader);
2333: }
2334: else
2335: {
2336: char *next;
2337:
2338: next = header_info;
2339:
2340: if (strlen(class_hint.res_name) != 0)
2341: {
2342: sprintf(header_info, "%s: ",
2343: class_hint.res_name);
2344:
2345: next += strlen(header_info);
2346: }
2347:
2348: sprintf(next, "%s @ %s",
2349: class_hint.res_class,
2350: hostname);
2351: }
2352:
2353:
2354: XStoreName(XXdisplay, w, header_info);
2355: }
2356:
2357:
2358: /* ------------------------------------------------------------
2359: * Set icon title to icon-name (from '-in'),
2360: * or if none, to "invocation-or-class @ host".
2361: *
2362: */
2363: static int
2364: XT_Set_Icon_Title(w)
2365: Window w;
2366: {
2367: char title_info[100];
2368:
2369: if (XXicon_name != (char *) NULL)
2370: {
2371: strcpy(title_info, XXicon_name);
2372: }
2373: else
2374: {
2375: if (strlen(class_hint.res_name) != 0)
2376: {
2377: sprintf(title_info, "%s@", class_hint.res_name);
2378: }
2379: else
2380: {
2381: sprintf(title_info, "%s@", class_hint.res_class);
2382: }
2383:
2384: strcat(title_info, hostname);
2385: }
2386:
2387:
2388: XChangeProperty(XXdisplay, w, XA_WM_ICON_NAME, XA_STRING, 8,
2389: PropModeReplace,
2390: (unsigned char *) title_info, strlen(title_info));
2391: }
2392:
2393:
2394: /* Arg PR carries value returned by XGeometry at startup, or 0. */
2395:
2396: static int
2397: XT_Set_Size_Hints(w, x, y, width, height, do_resize, pr)
2398: int x, y; /* only used at Startup: do_resize == FALSE */
2399: int width, height;
2400: Window w;
2401: Bool do_resize;
2402: int pr;
2403: {
2404: #ifndef X11R4
2405: XSizeHints sizehints;
2406:
2407: sizehints.flags = (pr & (WidthValue | HeightValue)) ? USSize : PSize;
2408:
2409: if (!do_resize)
2410: sizehints.flags |= (pr & (XValue | YValue)) ? USPosition : PPosition;
2411:
2412: sizehints.flags |= PResizeInc|PMinSize;
2413:
2414:
2415: sizehints.x = x;
2416: sizehints.y = y;
2417: sizehints.width = width*XXfontw + 2 * XXInternalBorder;
2418: sizehints.height = height*XXfonth + 2 * XXInternalBorder;
2419:
2420: pixelwidth = sizehints.width;
2421: pixelheight = sizehints.height;
2422: flexlines = height;
2423:
2424:
2425: change_screen_size (height, width, 0 - (do_resize == False), 0, 0);
2426:
2427: sizehints.width_inc = XXfontw;
2428: sizehints.height_inc = XXfonth;
2429:
2430: sizehints.min_width = XXfontw*MINWIDTH+2*XXInternalBorder;
2431: sizehints.min_height = XXfonth*MINHEIGHT+2*XXInternalBorder;
2432:
2433: #if 0
2434: /* old, broken versions */
2435: sizehints.min_width = 3 * XXInternalBorder;
2436: sizehints.min_height = 3 * XXInternalBorder;
2437: #endif
2438:
2439: XSetNormalHints(XXdisplay, w, &sizehints);
2440:
2441: if (do_resize)
2442: {
2443: XResizeWindow(XXdisplay, XXwindow, pixelwidth, pixelheight);
2444: XFlush(XXdisplay);
2445: }
2446: #else /* not X11R4 */
2447: XSizeHints sizehints;
2448: XWindowChanges changes;
2449: unsigned int change_mask = 0;
2450:
2451: sizehints.flags = 0;
2452:
2453: if (! do_resize) {
2454: changes.x = x;
2455: changes.y = y;
2456: sizehints.flags |= (pr & (XValue | YValue)) ? USPosition : PPosition;
2457: change_mask |= CWX | CWY;
2458: }
2459:
2460: sizehints.base_width = 2 * XXInternalBorder;
2461: sizehints.base_height = 2 * XXInternalBorder;
2462: changes.width = sizehints.base_width + width * XXfontw;
2463: changes.height = sizehints.base_height + height * XXfonth;
2464: sizehints.flags |= ((pr & (WidthValue | HeightValue)) ? USSize : PSize) |
2465: PBaseSize;
2466:
2467: /* If user has specified precise position, ... */
2468: if ((pr & XValue) || (pr & YValue))
2469: {
2470: sizehints.flags |= USSize | USPosition | PWinGravity;
2471: /* Tell window manager which corner to keep fixed. */
2472: switch (pr & (XNegative | YNegative))
2473: {
2474: case 0:
2475: sizehints.win_gravity = NorthWestGravity;
2476: break;
2477: case XNegative:
2478: sizehints.win_gravity = NorthEastGravity;
2479: break;
2480: case YNegative:
2481: sizehints.win_gravity = SouthWestGravity;
2482: break;
2483: default:
2484: sizehints.win_gravity = SouthEastGravity;
2485: break;
2486: }
2487: }
2488:
2489: change_mask |= CWWidth | CWHeight;
2490:
2491: /*
2492: * NOTE: The sizehints.x, sizehints.y, sizehints.width and
2493: * sizehints.height fields are OBSOLETE according to the ICCC, and
2494: * no window manager should be considering them, even if USSize/PSize
2495: * and/or USPosition/PPosition are set. Unfortunately, many
2496: * window managers consider them anyway, and programs like xprop
2497: * display their values when fetching the normal hints property
2498: * from the window. Therefore, I set them here just to make
2499: * things a little bit more robust.
2500: */
2501: if (! do_resize) {
2502: sizehints.x = x;
2503: sizehints.y = y;
2504: }
2505: sizehints.width = changes.width;
2506: sizehints.height = changes.height;
2507:
2508: pixelwidth = sizehints.base_width;
2509: pixelheight = sizehints.base_height;
2510: flexlines = height;
2511:
2512: change_screen_size (height, width, 0 - (do_resize == False), 0, 0);
2513:
2514: sizehints.min_width = XXfontw * MINWIDTH + 2 * XXInternalBorder;
2515: sizehints.min_height = XXfonth * MINHEIGHT + 2 * XXInternalBorder;
2516: sizehints.flags |= PMinSize;
2517:
2518: sizehints.width_inc = XXfontw;
2519: sizehints.height_inc = XXfonth;
2520: sizehints.flags |= PResizeInc;
2521:
2522: XSetWMNormalHints(XXdisplay, w, &sizehints);
2523: XConfigureWindow(XXdisplay, w, change_mask, &changes);
2524: #endif /* not X11R4 */
2525: }
2526:
2527:
2528: /* ------------------------------------------------------------
2529: */
2530: /*ARGSUSED*/
2531: static int
2532: XT_Set_Zoom_Sizes(w)
2533: Window w;
2534: {
2535: }
2536:
2537:
2538: /* ------------------------------------------------------------
2539: * Set our state and icon parameters.
2540: */
2541: static int
2542: XT_Set_WM_Hints(w)
2543: Window w;
2544: {
2545: XWMHints wmhints;
2546:
2547: wmhints.flags = InputHint | StateHint;
2548: if (XXicon_usebitmap)
2549: wmhints.flags |= IconPixmapHint | IconMaskHint;
2550:
2551: wmhints.input = True;
2552: wmhints.initial_state = NormalState;
2553:
2554: SinkPixmap = XCreateBitmapFromData (XXdisplay, w,
2555: sink_bits, sink_width,
2556: sink_height);
2557:
2558: SinkMaskPixmap = XCreateBitmapFromData (XXdisplay, w,
2559: sink_mask_bits,
2560: sink_mask_width,
2561: sink_mask_height);
2562:
2563: if (XXicon_usebitmap) {
2564: wmhints.icon_pixmap = SinkPixmap;
2565: wmhints.icon_mask = SinkMaskPixmap;
2566: }
2567: else {
2568: wmhints.icon_pixmap = 0;
2569: wmhints.icon_mask = 0;
2570: }
2571:
2572: XSetWMHints(XXdisplay, w, &wmhints);
2573: }
2574:
2575:
2576: /* ------------------------------------------------------------
2577: * Change just the size of the window.
2578: */
2579: XSetWindowSize(rows, cols)
2580: int rows, cols;
2581: {
2582: XT_Set_Size_Hints(XXwindow, 0, 0, cols, rows, NO_MANAGER, 0);
2583: }
2584:
2585:
2586: /* ------------------------------------------------------------
2587: */
2588: static int
2589: XInitWindow ()
2590: {
2591: extern int xargc;
2592: extern char **xargv;
2593: int x, y, width, height, pr;
2594: char *dp;
2595: Window desktop;
2596: XColor forec, backc;
2597:
2598:
2599: retry:
2600: fontinfo = XT_CalcForFont(XXcurrentfont);
2601: if (fontinfo == (XFontStruct *) NULL)
2602: {
2603: if (strcmp (XXcurrentfont, "fixed"))
2604: {
2605: free (XXcurrentfont);
2606: XXcurrentfont = (char *) xmalloc (6);
2607: strcpy (XXcurrentfont, "fixed");
2608: goto retry;
2609: }
2610: fatal ("X server unable to find requested font `%s'\n",
2611: (XXcurrentfont == NULL) ? "(null)" : XXcurrentfont);
2612: }
2613:
2614: pr = XGeometry (XXdisplay, 0, desiredwindow, default_window,
2615: XXborder, XXfontw, XXfonth,
2616: XXInternalBorder*2, XXInternalBorder*2,
2617: &x, &y, &width, &height);
2618:
2619: /* Which desktop do we start up on?
2620: */
2621: if ( (dp = getenv("WM_DESKTOP")) != (char *) NULL )
2622: {
2623: desktop = atoi(dp);
2624: }
2625: else
2626: {
2627: desktop = RootWindow(XXdisplay, DefaultScreen(XXdisplay));
2628: }
2629:
2630: XXwindow = XCreateSimpleWindow(XXdisplay, desktop,
2631: x, y,
2632: width*XXfontw + 2*XXInternalBorder,
2633: height*XXfonth + 2*XXInternalBorder,
2634: XXborder, brdr, back);
2635: if (!XXwindow)
2636: {
2637: fprintf (stderr, "Could not create X window!\n");
2638: fflush (stderr);
2639: exit (-97);
2640: }
2641:
2642: XXgcv.font = XXfid;
2643: XXgcv.foreground = fore;
2644: XXgcv.background = back;
2645: XXgc_norm = XCreateGC(XXdisplay, XXwindow,
2646: GCFont|GCForeground|GCBackground,
2647: &XXgcv);
2648: XXgcv.foreground = back;
2649: XXgcv.background = fore;
2650: XXgc_rev = XCreateGC(XXdisplay, XXwindow,
2651: GCFont|GCForeground|GCBackground,
2652: &XXgcv);
2653: XXgcv.foreground = back;
2654: XXgcv.background = curs;
2655: XXgc_curs = XCreateGC(XXdisplay, XXwindow,
2656: GCFont|GCForeground|GCBackground,
2657: &XXgcv);
2658: XXgcv.foreground = curs;
2659: XXgcv.background = back;
2660: XXgc_curs_rev = XCreateGC(XXdisplay, XXwindow,
2661: GCFont|GCForeground|GCBackground,
2662: &XXgcv);
2663:
2664: EmacsCursor = XCreateFontCursor(XXdisplay, XC_left_ptr);
2665:
2666: x_set_cursor_colors ();
2667:
2668: XDefineCursor (XXdisplay, XXwindow, EmacsCursor);
2669:
2670: CursorExists = 0;
2671: CursorOutline = 1;
2672: VisibleX = 0;
2673: VisibleY = 0;
2674:
2675:
2676: XT_Set_Class_Hints(XXwindow);
2677: XT_Set_Command_Line(XXwindow);
2678: XT_Set_Host(XXwindow);
2679: XT_Set_Title(XXwindow);
2680: XT_Set_Icon_Title(XXwindow);
2681: XT_Set_Size_Hints(XXwindow, x, y, width, height, False, pr);
2682: XT_Set_Zoom_Sizes(XXwindow);
2683: XT_Set_WM_Hints(XXwindow);
2684:
2685: XSelectInput(XXdisplay, XXwindow, KeyPressMask |
2686: ExposureMask | ButtonPressMask | ButtonReleaseMask |
2687: EnterWindowMask | LeaveWindowMask | FocusChangeMask |
2688: StructureNotifyMask);
2689:
2690: XMapWindow (XXdisplay, XXwindow);
2691: XFlush (XXdisplay);
2692:
2693: #ifdef AIX
2694: #include "xkeys-aix.h"
2695: #endif /* AIX */
2696:
2697: /* Free XrmGetStringDatabase */
2698:
2699: #ifndef NO_X_DESTROY_DATABASE
2700: XrmDestroyDatabase (db);
2701: #if (XlibSpecificationRelease >= 5)
2702: XrmDestroyDatabase (db2);
2703: #endif
2704: #endif
2705: }
2706:
2707: #endif /* HAVE_X_WINDOWS */
2708:
2709: /*#include "xundebug.h"*/
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.