1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 1993, 1994, 1995 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
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 2, or (at your option)
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.
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, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Xt features made by Fred Pierresteguy. */
23 /* On 4.3 these lose if they come after xterm.h. */
24 /* On HP-UX 8.0 signal.h loses if it comes after config.h. */
25 /* Putting these at the beginning seems to be standard for other .c files. */
32 /* Need syssignal.h for various externs and definitions that may be required
33 by some configurations for calls to signal later in this source file. */
34 #include "syssignal.h"
39 #include "blockinput.h"
41 /* This may include sys/types.h, and that somehow loses
42 if this is not done before the other system files. */
44 #include <X11/cursorfont.h>
47 /* Load sys/types.h if not already loaded.
48 In some systems loading it twice is suicidal. */
50 #include <sys/types.h>
55 #include <sys/ioctl.h>
56 #endif /* ! defined (BSD) */
61 #ifndef INCLUDED_FCNTL
68 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
69 /* #include <sys/param.h> */
72 #include "dispextern.h"
73 #include "termhooks.h"
85 #include "intervals.h"
88 extern void free_frame_menubar ();
89 extern FRAME_PTR
x_menubar_window_to_frame ();
90 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
92 extern void _XEditResCheckMessages ();
93 #endif /* not NO_EDITRES */
94 #endif /* USE_X_TOOLKIT */
97 #define x_any_window_to_frame x_window_to_frame
98 #define x_top_window_to_frame x_window_to_frame
103 #ifndef XtNinitialState
104 #define XtNinitialState "initialState"
109 /* So we can do setlocale. */
114 /* For XlibDisplayWriting */
115 #include <X11/Xlibint.h>
118 #define min(a,b) ((a)<(b) ? (a) : (b))
119 #define max(a,b) ((a)>(b) ? (a) : (b))
121 /* This is a chain of structures for all the X displays currently in use. */
122 struct x_display_info
*x_display_list
;
124 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
125 one for each element of x_display_list and in the same order.
126 NAME is the name of the frame.
127 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
128 Lisp_Object x_display_name_list
;
130 /* Frame being updated by update_frame. This is declared in term.c.
131 This is set by update_begin and looked at by all the
132 XT functions. It is zero while not inside an update.
133 In that case, the XT functions assume that `selected_frame'
134 is the frame to apply to. */
135 extern struct frame
*updating_frame
;
137 /* This is a frame waiting to be autoraised, within XTread_socket. */
138 struct frame
*pending_autoraise_frame
;
141 /* The application context for Xt use. */
142 XtAppContext Xt_app_con
;
144 static String Xt_default_resources
[] =
150 /* During an update, maximum vpos for ins/del line operations to affect. */
152 static int flexlines
;
154 /* During an update, nonzero if chars output now should be highlighted. */
156 static int highlight
;
158 /* Nominal cursor position -- where to draw output.
159 During an update, these are different from the cursor-box position. */
166 In order to avoid asking for motion events and then throwing most
167 of them away or busy-polling the server for mouse positions, we ask
168 the server for pointer motion hints. This means that we get only
169 one event per group of mouse movements. "Groups" are delimited by
170 other kinds of events (focus changes and button clicks, for
171 example), or by XQueryPointer calls; when one of these happens, we
172 get another MotionNotify event the next time the mouse moves. This
173 is at least as efficient as getting motion events when mouse
174 tracking is on, and I suspect only negligibly worse when tracking
177 The silly O'Reilly & Associates Nutshell guides barely document
178 pointer motion hints at all (I think you have to infer how they
179 work from an example), and the description of XQueryPointer doesn't
180 mention that calling it causes you to get another motion hint from
181 the server, which is very important. */
183 /* Where the mouse was last time we reported a mouse event. */
184 static FRAME_PTR last_mouse_frame
;
185 static XRectangle last_mouse_glyph
;
187 /* The scroll bar in which the last X motion event occurred.
189 If the last X motion event occurred in a scroll bar, we set this
190 so XTmouse_position can know whether to report a scroll bar motion or
193 If the last X motion event didn't occur in a scroll bar, we set this
194 to Qnil, to tell XTmouse_position to return an ordinary motion event. */
195 static Lisp_Object last_mouse_scroll_bar
;
197 /* This is a hack. We would really prefer that XTmouse_position would
198 return the time associated with the position it returns, but there
199 doesn't seem to be any way to wrest the timestamp from the server
200 along with the position query. So, we just keep track of the time
201 of the last movement we received, and return that in hopes that
202 it's somewhat accurate. */
203 static Time last_mouse_movement_time
;
205 /* Incremented by XTread_socket whenever it really tries to read events. */
207 static int volatile input_signal_count
;
209 static int input_signal_count
;
212 /* Used locally within XTread_socket. */
213 static int x_noop_count
;
215 /* Initial values of argv and argc. */
216 extern char **initial_argv
;
217 extern int initial_argc
;
219 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
221 /* Tells if a window manager is present or not. */
223 extern Lisp_Object Vx_no_window_manager
;
225 /* Nonzero enables some debugging for the X interface code. */
228 extern Lisp_Object Qface
, Qmouse_face
;
232 /* A mask of extra modifier bits to put into every keyboard char. */
233 extern int extra_keyboard_modifiers
;
235 static Lisp_Object Qvendor_specific_keysyms
;
237 extern XrmDatabase
x_load_resources ();
239 extern Lisp_Object
x_icon_type ();
241 void x_delete_display ();
243 static void redraw_previous_char ();
244 static void redraw_following_char ();
245 static unsigned int x_x_to_emacs_modifiers ();
247 static int fast_find_position ();
248 static void note_mouse_highlight ();
249 static void clear_mouse_face ();
250 static void show_mouse_face ();
251 static void do_line_dance ();
253 static int XTcursor_to ();
254 static int XTclear_end_of_line ();
255 static int x_io_error_quitter ();
256 void x_catch_errors ();
257 void x_uncatch_errors ();
260 /* This is a function useful for recording debugging information
261 about the sequence of occurrences in this file. */
269 struct record event_record
[100];
271 int event_record_index
;
273 record_event (locus
, type
)
277 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
278 event_record_index
= 0;
280 event_record
[event_record_index
].locus
= locus
;
281 event_record
[event_record_index
].type
= type
;
282 event_record_index
++;
287 /* Return the struct x_display_info corresponding to DPY. */
289 struct x_display_info
*
290 x_display_info_for_display (dpy
)
293 struct x_display_info
*dpyinfo
;
295 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
296 if (dpyinfo
->display
== dpy
)
302 /* Starting and ending updates.
304 These hooks are called by update_frame at the beginning and end
305 of a frame update. We record in `updating_frame' the identity
306 of the frame being updated, so that the XT... functions do not
307 need to take a frame as argument. Most of the XT... functions
308 should never be called except during an update, the only exceptions
309 being XTcursor_to, XTwrite_glyphs and XTreassert_line_highlight. */
320 flexlines
= f
->height
;
325 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
327 /* Don't do highlighting for mouse motion during the update. */
328 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 1;
330 /* If the frame needs to be redrawn,
331 simply forget about any prior mouse highlighting. */
332 if (FRAME_GARBAGED_P (f
))
333 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= Qnil
;
335 if (!NILP (FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
))
337 int firstline
, lastline
, i
;
338 struct window
*w
= XWINDOW (FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
);
340 /* Find the first, and the last+1, lines affected by redisplay. */
341 for (firstline
= 0; firstline
< f
->height
; firstline
++)
342 if (FRAME_DESIRED_GLYPHS (f
)->enable
[firstline
])
345 lastline
= f
->height
;
346 for (i
= f
->height
- 1; i
>= 0; i
--)
348 if (FRAME_DESIRED_GLYPHS (f
)->enable
[i
])
354 /* Can we tell that this update does not affect the window
355 where the mouse highlight is? If so, no need to turn off.
356 Likewise, don't do anything if the frame is garbaged;
357 in that case, the FRAME_CURRENT_GLYPHS that we would use
358 are all wrong, and we will redisplay that line anyway. */
359 if (! (firstline
> (XFASTINT (w
->top
) + window_internal_height (w
))
360 || lastline
< XFASTINT (w
->top
)))
361 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
377 x_display_cursor (f
, 1);
379 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
380 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
382 /* This fails in the case of having updated only the echo area
383 if we have switched buffers. In that case, FRAME_CURRENT_GLYPHS
384 has no relation to the current contents, and its charstarts
385 have no relation to the contents of the window-buffer.
386 I don't know a clean way to check
387 for that case. window_end_valid isn't set up yet. */
388 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
389 note_mouse_highlight (f
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
390 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
393 XFlush (FRAME_X_DISPLAY (f
));
397 /* This is called after a redisplay on frame F. */
400 XTframe_up_to_date (f
)
404 if (FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
405 || f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
407 note_mouse_highlight (FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
,
408 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
409 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
410 FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 0;
415 /* External interface to control of standout mode.
416 Call this when about to modify line at position VPOS
417 and not change whether it is highlighted. */
419 XTreassert_line_highlight (new, vpos
)
425 /* Call this when about to modify line at position VPOS
426 and change whether it is highlighted. */
429 XTchange_line_highlight (new_highlight
, vpos
, first_unused_hpos
)
430 int new_highlight
, vpos
, first_unused_hpos
;
432 highlight
= new_highlight
;
433 XTcursor_to (vpos
, 0);
434 XTclear_end_of_line (updating_frame
->width
);
437 /* This is used when starting Emacs and when restarting after suspend.
438 When starting Emacs, no X window is mapped. And nothing must be done
439 to Emacs's own window if it is suspended (though that rarely happens). */
442 XTset_terminal_modes ()
446 /* This is called when exiting or suspending Emacs.
447 Exiting will make the X-windows go away, and suspending
448 requires no action. */
451 XTreset_terminal_modes ()
453 /* XTclear_frame (); */
456 /* Set the nominal cursor position of the frame.
457 This is where display update commands will take effect.
458 This does not affect the place where the cursor-box is displayed. */
461 XTcursor_to (row
, col
)
462 register int row
, col
;
470 if (updating_frame
== 0)
473 x_display_cursor (selected_frame
, 1);
474 XFlush (FRAME_X_DISPLAY (selected_frame
));
479 /* Display a sequence of N glyphs found at GP.
480 WINDOW is the x-window to output to. LEFT and TOP are starting coords.
481 HL is 1 if this text is highlighted, 2 if the cursor is on it,
482 3 if should appear in its mouse-face.
483 JUST_FOREGROUND if 1 means draw only the foreground;
484 don't alter the background.
486 FONT is the default font to use (for glyphs whose font-code is 0).
488 Since the display generation code is responsible for calling
489 compute_char_face and compute_glyph_face on everything it puts in
490 the display structure, we can assume that the face code on each
491 glyph is a valid index into FRAME_COMPUTED_FACES (f), and the one
492 to which we can actually apply intern_face.
493 Call this function with input blocked. */
496 /* This is the multi-face code. */
499 dumpglyphs (f
, left
, top
, gp
, n
, hl
, just_foreground
)
502 register GLYPH
*gp
; /* Points to first GLYPH. */
503 register int n
; /* Number of glyphs to display. */
507 /* Holds characters to be displayed. */
508 char *buf
= (char *) alloca (f
->width
* sizeof (*buf
));
509 register char *cp
; /* Steps through buf[]. */
510 register int tlen
= GLYPH_TABLE_LENGTH
;
511 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
512 Window window
= FRAME_X_WINDOW (f
);
513 int orig_left
= left
;
517 /* Get the face-code of the next GLYPH. */
521 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
522 cf
= FAST_GLYPH_FACE (g
);
524 /* Find the run of consecutive glyphs with the same face-code.
525 Extract their character codes into BUF. */
530 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
531 if (FAST_GLYPH_FACE (g
) != cf
)
534 *cp
++ = FAST_GLYPH_CHAR (g
);
539 /* LEN gets the length of the run. */
542 /* Now output this run of chars, with the font and pixel values
543 determined by the face code CF. */
545 struct face
*face
= FRAME_DEFAULT_FACE (f
);
546 XFontStruct
*font
= FACE_FONT (face
);
547 GC gc
= FACE_GC (face
);
550 /* HL = 3 means use a mouse face previously chosen. */
552 cf
= FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
;
554 /* First look at the face of the text itself. */
557 /* It's possible for the display table to specify
558 a face code that is out of range. Use 0 in that case. */
559 if (cf
< 0 || cf
>= FRAME_N_COMPUTED_FACES (f
)
560 || FRAME_COMPUTED_FACES (f
) [cf
] == 0)
564 face
= FRAME_MODE_LINE_FACE (f
);
566 face
= intern_face (f
, FRAME_COMPUTED_FACES (f
) [cf
]);
567 font
= FACE_FONT (face
);
569 if (FACE_STIPPLE (face
))
573 /* Then comes the distinction between modeline and normal text. */
578 face
= FRAME_MODE_LINE_FACE (f
);
579 font
= FACE_FONT (face
);
581 if (FACE_STIPPLE (face
))
585 #define FACE_DEFAULT (~0)
587 /* Now override that if the cursor's on this character. */
590 /* The cursor overrides stippling. */
594 || face
->font
== (XFontStruct
*) FACE_DEFAULT
595 || face
->font
== f
->output_data
.x
->font
)
596 && face
->background
== f
->output_data
.x
->background_pixel
597 && face
->foreground
== f
->output_data
.x
->foreground_pixel
)
599 gc
= f
->output_data
.x
->cursor_gc
;
601 /* Cursor on non-default face: must merge. */
607 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
608 xgcv
.foreground
= face
->background
;
609 /* If the glyph would be invisible,
610 try a different foreground. */
611 if (xgcv
.foreground
== xgcv
.background
)
612 xgcv
.foreground
= face
->foreground
;
613 if (xgcv
.foreground
== xgcv
.background
)
614 xgcv
.foreground
= f
->output_data
.x
->cursor_foreground_pixel
;
615 if (xgcv
.foreground
== xgcv
.background
)
616 xgcv
.foreground
= face
->foreground
;
617 /* Make sure the cursor is distinct from text in this face. */
618 if (xgcv
.background
== face
->background
619 && xgcv
.foreground
== face
->foreground
)
621 xgcv
.background
= face
->foreground
;
622 xgcv
.foreground
= face
->background
;
624 xgcv
.font
= face
->font
->fid
;
625 xgcv
.graphics_exposures
= 0;
626 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
627 if (FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
)
628 XChangeGC (FRAME_X_DISPLAY (f
),
629 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
,
632 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
633 = XCreateGC (FRAME_X_DISPLAY (f
), window
, mask
, &xgcv
);
634 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
636 /* If this code is restored, it must also reset to the default stipple
638 if (face
->stipple
&& face
->stipple
!= FACE_DEFAULT
)
639 XSetStipple (FRAME_X_DISPLAY (f
), gc
, face
->stipple
);
644 if (font
== (XFontStruct
*) FACE_DEFAULT
)
645 font
= f
->output_data
.x
->font
;
648 XDrawString (FRAME_X_DISPLAY (f
), window
, gc
,
649 left
, top
+ FONT_BASE (font
), buf
, len
);
654 /* Turn stipple on. */
655 XSetFillStyle (FRAME_X_DISPLAY (f
), gc
, FillOpaqueStippled
);
657 /* Draw stipple on background. */
658 XFillRectangle (FRAME_X_DISPLAY (f
), window
, gc
,
660 FONT_WIDTH (font
) * len
,
663 /* Turn stipple off. */
664 XSetFillStyle (FRAME_X_DISPLAY (f
), gc
, FillSolid
);
666 /* Draw the text, solidly, onto the stipple pattern. */
667 XDrawString (FRAME_X_DISPLAY (f
), window
, gc
,
668 left
, top
+ FONT_BASE (font
), buf
, len
);
671 XDrawImageString (FRAME_X_DISPLAY (f
), window
, gc
,
672 left
, top
+ FONT_BASE (font
), buf
, len
);
674 /* Clear the rest of the line's height. */
675 if (f
->output_data
.x
->line_height
!= FONT_HEIGHT (font
))
676 XClearArea (FRAME_X_DISPLAY (f
), window
, left
,
677 top
+ FONT_HEIGHT (font
),
678 FONT_WIDTH (font
) * len
,
679 /* This is how many pixels of height
681 f
->output_data
.x
->line_height
- FONT_HEIGHT (font
),
685 #if 0 /* Doesn't work, because it uses FRAME_CURRENT_GLYPHS,
686 which often is not up to date yet. */
687 if (!just_foreground
)
689 if (left
== orig_left
)
690 redraw_previous_char (f
, PIXEL_TO_CHAR_COL (f
, left
),
691 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
693 redraw_following_char (f
, PIXEL_TO_CHAR_COL (f
, left
+ len
* FONT_WIDTH (font
)),
694 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
698 /* We should probably check for XA_UNDERLINE_POSITION and
699 XA_UNDERLINE_THICKNESS properties on the font, but let's
700 just get the thing working, and come back to that. */
702 int underline_position
= 1;
704 if (font
->descent
<= underline_position
)
705 underline_position
= font
->descent
- 1;
708 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
712 + underline_position
),
713 len
* FONT_WIDTH (font
), 1);
716 left
+= len
* FONT_WIDTH (font
);
723 /* This is the old single-face code. */
726 dumpglyphs (f
, left
, top
, gp
, n
, hl
, font
)
729 register GLYPH
*gp
; /* Points to first GLYPH. */
730 register int n
; /* Number of glyphs to display. */
735 Window window
= FRAME_X_WINDOW (f
);
736 GC drawing_gc
= (hl
== 2 ? f
->output_data
.x
->cursor_gc
737 : (hl
? f
->output_data
.x
->reverse_gc
738 : f
->output_data
.x
->normal_gc
));
740 if (sizeof (GLYPH
) == sizeof (XChar2b
))
741 XDrawImageString16 (FRAME_X_DISPLAY (f
), window
, drawing_gc
,
742 left
, top
+ FONT_BASE (font
), (XChar2b
*) gp
, n
);
743 else if (sizeof (GLYPH
) == sizeof (unsigned char))
744 XDrawImageString (FRAME_X_DISPLAY (f
), window
, drawing_gc
,
745 left
, top
+ FONT_BASE (font
), (char *) gp
, n
);
747 /* What size of glyph ARE you using? And does X have a function to
753 /* Output some text at the nominal frame cursor position.
754 Advance the cursor over the text.
755 Output LEN glyphs at START.
757 `highlight', set up by XTreassert_line_highlight or XTchange_line_highlight,
758 controls the pixel values used for foreground and background. */
761 XTwrite_glyphs (start
, len
)
762 register GLYPH
*start
;
765 register int temp_length
;
776 /* If not within an update,
777 output at the frame's visible cursor. */
778 curs_x
= f
->cursor_x
;
779 curs_y
= f
->cursor_y
;
783 CHAR_TO_PIXEL_COL (f
, curs_x
),
784 CHAR_TO_PIXEL_ROW (f
, curs_y
),
785 start
, len
, highlight
, 0);
787 /* If we drew on top of the cursor, note that it is turned off. */
788 if (curs_y
== f
->phys_cursor_y
789 && curs_x
<= f
->phys_cursor_x
790 && curs_x
+ len
> f
->phys_cursor_x
)
791 f
->phys_cursor_x
= -1;
793 if (updating_frame
== 0)
796 x_display_cursor (f
, 1);
805 /* Clear to the end of the line.
806 Erase the current text line from the nominal cursor position (inclusive)
807 to column FIRST_UNUSED (exclusive). The idea is that everything
808 from FIRST_UNUSED onward is already erased. */
811 XTclear_end_of_line (first_unused
)
812 register int first_unused
;
814 struct frame
*f
= updating_frame
;
820 if (curs_y
< 0 || curs_y
>= f
->height
)
822 if (first_unused
<= 0)
825 if (first_unused
>= f
->width
)
826 first_unused
= f
->width
;
832 /* Notice if the cursor will be cleared by this operation. */
833 if (curs_y
== f
->phys_cursor_y
834 && curs_x
<= f
->phys_cursor_x
835 && f
->phys_cursor_x
< first_unused
)
836 f
->phys_cursor_x
= -1;
838 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
839 CHAR_TO_PIXEL_COL (f
, curs_x
),
840 CHAR_TO_PIXEL_ROW (f
, curs_y
),
841 FONT_WIDTH (f
->output_data
.x
->font
) * (first_unused
- curs_x
),
842 f
->output_data
.x
->line_height
, False
);
844 redraw_previous_char (f
, curs_x
, curs_y
, highlight
);
854 struct frame
*f
= updating_frame
;
859 f
->phys_cursor_x
= -1; /* Cursor not visible. */
860 curs_x
= 0; /* Nominal cursor position is top left. */
865 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
867 /* We have to clear the scroll bars, too. If we have changed
868 colors or something like that, then they should be notified. */
869 x_scroll_bar_clear (f
);
871 XFlush (FRAME_X_DISPLAY (f
));
876 /* This currently does not work because FRAME_CURRENT_GLYPHS doesn't
877 always contain the right glyphs to use.
879 It also needs to be changed to look at the details of the font and
880 see whether there is really overlap, and do nothing when there is
881 not. This can use font_char_overlap_left and font_char_overlap_right,
882 but just how to use them is not clear. */
884 /* Erase the character (if any) at the position just before X, Y in frame F,
885 then redraw it and the character before it.
886 This is necessary when we erase starting at X,
887 in case the character after X overlaps into the one before X.
888 Call this function with input blocked. */
891 redraw_previous_char (f
, x
, y
, highlight_flag
)
896 /* Erase the character before the new ones, in case
897 what was here before overlaps it.
898 Reoutput that character, and the previous character
899 (in case the previous character overlaps it). */
905 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
906 CHAR_TO_PIXEL_COL (f
, x
- 1),
907 CHAR_TO_PIXEL_ROW (f
, y
),
908 FONT_WIDTH (f
->output_data
.x
->font
),
909 f
->output_data
.x
->line_height
, False
);
911 dumpglyphs (f
, CHAR_TO_PIXEL_COL (f
, start_x
),
912 CHAR_TO_PIXEL_ROW (f
, y
),
913 &FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][start_x
],
914 x
- start_x
, highlight_flag
, 1);
918 /* Erase the character (if any) at the position X, Y in frame F,
919 then redraw it and the character after it.
920 This is necessary when we erase endng at X,
921 in case the character after X overlaps into the one before X.
922 Call this function with input blocked. */
925 redraw_following_char (f
, x
, y
, highlight_flag
)
930 int limit
= FRAME_CURRENT_GLYPHS (f
)->used
[y
];
931 /* Erase the character after the new ones, in case
932 what was here before overlaps it.
933 Reoutput that character, and the following character
934 (in case the following character overlaps it). */
936 && FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][x
] != SPACEGLYPH
)
941 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
942 CHAR_TO_PIXEL_COL (f
, x
),
943 CHAR_TO_PIXEL_ROW (f
, y
),
944 FONT_WIDTH (f
->output_data
.x
->font
),
945 f
->output_data
.x
->line_height
, False
);
947 dumpglyphs (f
, CHAR_TO_PIXEL_COL (f
, x
),
948 CHAR_TO_PIXEL_ROW (f
, y
),
949 &FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][x
],
950 end_x
- x
, highlight_flag
, 1);
955 #if 0 /* Not in use yet */
957 /* Return 1 if character C in font F extends past its left edge. */
960 font_char_overlap_left (font
, c
)
966 /* Find the bounding-box info for C. */
967 if (font
->per_char
== 0)
968 s
= &font
->max_bounds
;
971 int rowlen
= font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1;
974 /* Decode char into row number (byte 1) and code within row (byte 2). */
977 if (!(within
>= font
->min_char_or_byte2
978 && within
<= font
->max_char_or_byte2
979 && row
>= font
->min_byte1
980 && row
<= font
->max_byte1
))
982 /* If char is out of range, try the font's default char instead. */
983 c
= font
->default_char
;
984 row
= c
>> (BITS_PER_INT
- 8);
987 if (!(within
>= font
->min_char_or_byte2
988 && within
<= font
->max_char_or_byte2
989 && row
>= font
->min_byte1
990 && row
<= font
->max_byte1
))
991 /* Still out of range means this char does not overlap. */
994 /* We found the info for this char. */
995 s
= (font
->per_char
+ (within
- font
->min_char_or_byte2
)
999 return (s
&& s
->lbearing
< 0);
1002 /* Return 1 if character C in font F extends past its right edge. */
1005 font_char_overlap_right (font
, c
)
1011 /* Find the bounding-box info for C. */
1012 if (font
->per_char
== 0)
1013 s
= &font
->max_bounds
;
1016 int rowlen
= font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1;
1019 /* Decode char into row number (byte 1) and code within row (byte 2). */
1022 if (!(within
>= font
->min_char_or_byte2
1023 && within
<= font
->max_char_or_byte2
1024 && row
>= font
->min_byte1
1025 && row
<= font
->max_byte1
))
1027 /* If char is out of range, try the font's default char instead. */
1028 c
= font
->default_char
;
1029 row
= c
>> (BITS_PER_INT
- 8);
1032 if (!(within
>= font
->min_char_or_byte2
1033 && within
<= font
->max_char_or_byte2
1034 && row
>= font
->min_byte1
1035 && row
<= font
->max_byte1
))
1036 /* Still out of range means this char does not overlap. */
1039 /* We found the info for this char. */
1040 s
= (font
->per_char
+ (within
- font
->min_char_or_byte2
)
1044 return (s
&& s
->rbearing
>= s
->width
);
1048 /* Invert the middle quarter of the frame for .15 sec. */
1050 /* We use the select system call to do the waiting, so we have to make sure
1051 it's available. If it isn't, we just won't do visual bells. */
1052 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
1054 /* Subtract the `struct timeval' values X and Y,
1055 storing the result in RESULT.
1056 Return 1 if the difference is negative, otherwise 0. */
1059 timeval_subtract (result
, x
, y
)
1060 struct timeval
*result
, x
, y
;
1062 /* Perform the carry for the later subtraction by updating y.
1063 This is safer because on some systems
1064 the tv_sec member is unsigned. */
1065 if (x
.tv_usec
< y
.tv_usec
)
1067 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
1068 y
.tv_usec
-= 1000000 * nsec
;
1071 if (x
.tv_usec
- y
.tv_usec
> 1000000)
1073 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
1074 y
.tv_usec
+= 1000000 * nsec
;
1078 /* Compute the time remaining to wait. tv_usec is certainly positive. */
1079 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
1080 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
1082 /* Return indication of whether the result should be considered negative. */
1083 return x
.tv_sec
< y
.tv_sec
;
1094 /* Create a GC that will use the GXxor function to flip foreground pixels
1095 into background pixels. */
1099 values
.function
= GXxor
;
1100 values
.foreground
= (f
->output_data
.x
->foreground_pixel
1101 ^ f
->output_data
.x
->background_pixel
);
1103 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1104 GCFunction
| GCForeground
, &values
);
1108 int width
= PIXEL_WIDTH (f
);
1109 int height
= PIXEL_HEIGHT (f
);
1111 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
1112 width
/4, height
/4, width
/2, height
/2);
1113 XFlush (FRAME_X_DISPLAY (f
));
1116 struct timeval wakeup
, now
;
1118 EMACS_GET_TIME (wakeup
);
1120 /* Compute time to wait until, propagating carry from usecs. */
1121 wakeup
.tv_usec
+= 150000;
1122 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
1123 wakeup
.tv_usec
%= 1000000;
1125 /* Keep waiting until past the time wakeup. */
1128 struct timeval timeout
;
1130 EMACS_GET_TIME (timeout
);
1132 /* In effect, timeout = wakeup - timeout.
1133 Break if result would be negative. */
1134 if (timeval_subtract (&timeout
, wakeup
, timeout
))
1137 /* Try to wait that long--but we might wake up sooner. */
1138 select (0, NULL
, NULL
, NULL
, &timeout
);
1142 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
1143 width
/4, height
/4, width
/2, height
/2);
1144 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
1145 XFlush (FRAME_X_DISPLAY (f
));
1155 /* Make audible bell. */
1157 #define XRINGBELL XBell (FRAME_X_DISPLAY (selected_frame), 0)
1161 if (FRAME_X_DISPLAY (selected_frame
) == 0)
1164 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
1166 XTflash (selected_frame
);
1172 XFlush (FRAME_X_DISPLAY (selected_frame
));
1177 /* Insert and delete character.
1178 These are not supposed to be used because we are supposed to turn
1179 off the feature of using them. */
1182 XTinsert_glyphs (start
, len
)
1183 register char *start
;
1196 /* Specify how many text lines, from the top of the window,
1197 should be affected by insert-lines and delete-lines operations.
1198 This, and those operations, are used only within an update
1199 that is bounded by calls to XTupdate_begin and XTupdate_end. */
1202 XTset_terminal_window (n
)
1205 if (updating_frame
== 0)
1208 if ((n
<= 0) || (n
> updating_frame
->height
))
1209 flexlines
= updating_frame
->height
;
1214 /* These variables need not be per frame
1215 because redisplay is done on a frame-by-frame basis
1216 and the line dance for one frame is finished before
1217 anything is done for anoter frame. */
1219 /* Array of line numbers from cached insert/delete operations.
1220 line_dance[i] is the old position of the line that we want
1221 to move to line i, or -1 if we want a blank line there. */
1222 static int *line_dance
;
1224 /* Allocated length of that array. */
1225 static int line_dance_len
;
1227 /* Flag indicating whether we've done any work. */
1228 static int line_dance_in_progress
;
1230 /* Perform an insert-lines or delete-lines operation,
1231 inserting N lines or deleting -N lines at vertical position VPOS. */
1232 XTins_del_lines (vpos
, n
)
1235 register int fence
, i
;
1237 if (vpos
>= flexlines
)
1240 if (!line_dance_in_progress
)
1242 int ht
= updating_frame
->height
;
1243 if (ht
> line_dance_len
)
1245 line_dance
= (int *)xrealloc (line_dance
, ht
* sizeof (int));
1246 line_dance_len
= ht
;
1248 for (i
= 0; i
< ht
; ++i
) line_dance
[i
] = i
;
1249 line_dance_in_progress
= 1;
1253 if (n
> flexlines
- vpos
)
1254 n
= flexlines
- vpos
;
1256 for (i
= flexlines
; --i
>= fence
;)
1257 line_dance
[i
] = line_dance
[i
-n
];
1258 for (i
= fence
; --i
>= vpos
;)
1264 if (n
> flexlines
- vpos
)
1265 n
= flexlines
- vpos
;
1266 fence
= flexlines
- n
;
1267 for (i
= vpos
; i
< fence
; ++i
)
1268 line_dance
[i
] = line_dance
[i
+ n
];
1269 for (i
= fence
; i
< flexlines
; ++i
)
1274 /* Here's where we actually move the pixels around.
1275 Must be called with input blocked. */
1279 register int i
, j
, distance
;
1280 register struct frame
*f
;
1284 /* Must check this flag first. If it's not set, then not only is the
1285 array uninitialized, but we might not even have a frame. */
1286 if (!line_dance_in_progress
)
1294 intborder
= f
->output_data
.x
->internal_border_width
;
1296 x_display_cursor (updating_frame
, 0);
1298 for (i
= 0; i
< ht
; ++i
)
1299 if (line_dance
[i
] != -1 && (distance
= line_dance
[i
]-i
) > 0)
1301 for (j
= i
; (j
< ht
&& line_dance
[j
] != -1
1302 && line_dance
[j
]-j
== distance
); ++j
);
1303 /* Copy [i,j) upward from [i+distance,j+distance) */
1304 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1305 FRAME_X_WINDOW (f
), f
->output_data
.x
->normal_gc
,
1306 intborder
, CHAR_TO_PIXEL_ROW (f
, i
+distance
),
1307 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1308 (j
-i
) * f
->output_data
.x
->line_height
,
1309 intborder
, CHAR_TO_PIXEL_ROW (f
, i
));
1313 for (i
= ht
; --i
>=0; )
1314 if (line_dance
[i
] != -1 && (distance
= line_dance
[i
]-i
) < 0)
1316 for (j
= i
; (--j
>= 0 && line_dance
[j
] != -1
1317 && line_dance
[j
]-j
== distance
););
1318 /* Copy (j,i] downward from (j+distance, i+distance] */
1319 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1320 FRAME_X_WINDOW (f
), f
->output_data
.x
->normal_gc
,
1321 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1+distance
),
1322 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1323 (i
-j
) * f
->output_data
.x
->line_height
,
1324 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1));
1328 for (i
= 0; i
< ht
; ++i
)
1329 if (line_dance
[i
] == -1)
1331 for (j
= i
; j
< ht
&& line_dance
[j
] == -1; ++j
);
1333 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1334 intborder
, CHAR_TO_PIXEL_ROW (f
, i
),
1335 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1336 (j
-i
) * f
->output_data
.x
->line_height
, False
);
1339 line_dance_in_progress
= 0;
1342 /* Support routines for exposure events. */
1343 static void clear_cursor ();
1345 /* Output into a rectangle of an X-window (for frame F)
1346 the characters in f->phys_lines that overlap that rectangle.
1347 TOP and LEFT are the position of the upper left corner of the rectangle.
1348 ROWS and COLS are the size of the rectangle.
1349 Call this function with input blocked. */
1352 dumprectangle (f
, left
, top
, cols
, rows
)
1354 register int left
, top
, cols
, rows
;
1356 register struct frame_glyphs
*active_frame
= FRAME_CURRENT_GLYPHS (f
);
1357 int cursor_cleared
= 0;
1361 if (FRAME_GARBAGED_P (f
))
1364 /* Express rectangle as four edges, instead of position-and-size. */
1365 bottom
= top
+ rows
;
1366 right
= left
+ cols
;
1368 /* Convert rectangle edges in pixels to edges in chars.
1369 Round down for left and top, up for right and bottom. */
1370 top
= PIXEL_TO_CHAR_ROW (f
, top
);
1371 left
= PIXEL_TO_CHAR_COL (f
, left
);
1372 bottom
+= (f
->output_data
.x
->line_height
- 1);
1373 right
+= (FONT_WIDTH (f
->output_data
.x
->font
) - 1);
1374 bottom
= PIXEL_TO_CHAR_ROW (f
, bottom
);
1375 right
= PIXEL_TO_CHAR_COL (f
, right
);
1377 /* Clip the rectangle to what can be visible. */
1382 if (right
> f
->width
)
1384 if (bottom
> f
->height
)
1387 /* Get size in chars of the rectangle. */
1388 cols
= right
- left
;
1389 rows
= bottom
- top
;
1391 /* If rectangle has zero area, return. */
1392 if (rows
<= 0) return;
1393 if (cols
<= 0) return;
1395 /* Turn off the cursor if it is in the rectangle.
1396 We will turn it back on afterward. */
1397 if ((f
->phys_cursor_x
>= left
) && (f
->phys_cursor_x
< right
)
1398 && (f
->phys_cursor_y
>= top
) && (f
->phys_cursor_y
< bottom
))
1404 /* Display the text in the rectangle, one text line at a time. */
1406 for (y
= top
; y
< bottom
; y
++)
1408 GLYPH
*line
= &active_frame
->glyphs
[y
][left
];
1410 if (! active_frame
->enable
[y
] || left
> active_frame
->used
[y
])
1414 CHAR_TO_PIXEL_COL (f
, left
),
1415 CHAR_TO_PIXEL_ROW (f
, y
),
1416 line
, min (cols
, active_frame
->used
[y
] - left
),
1417 active_frame
->highlight
[y
], 0);
1420 /* Turn the cursor on if we turned it off. */
1423 x_display_cursor (f
, 1);
1430 /* We used to only do this if Vx_no_window_manager was non-nil, but
1431 the ICCCM (section 4.1.6) says that the window's border pixmap
1432 and border pixel are window attributes which are "private to the
1433 client", so we can always change it to whatever we want. */
1435 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1436 f
->output_data
.x
->border_pixel
);
1438 x_update_cursor (f
, 1);
1442 frame_unhighlight (f
)
1445 /* We used to only do this if Vx_no_window_manager was non-nil, but
1446 the ICCCM (section 4.1.6) says that the window's border pixmap
1447 and border pixel are window attributes which are "private to the
1448 client", so we can always change it to whatever we want. */
1450 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1451 f
->output_data
.x
->border_tile
);
1453 x_update_cursor (f
, 1);
1456 static void XTframe_rehighlight ();
1457 static void x_frame_rehighlight ();
1459 /* The focus has changed. Update the frames as necessary to reflect
1460 the new situation. Note that we can't change the selected frame
1461 here, because the Lisp code we are interrupting might become confused.
1462 Each event gets marked with the frame in which it occurred, so the
1463 Lisp code can tell when the switch took place by examining the events. */
1466 x_new_focus_frame (dpyinfo
, frame
)
1467 struct x_display_info
*dpyinfo
;
1468 struct frame
*frame
;
1470 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
1471 int events_enqueued
= 0;
1473 if (frame
!= dpyinfo
->x_focus_frame
)
1475 /* Set this before calling other routines, so that they see
1476 the correct value of x_focus_frame. */
1477 dpyinfo
->x_focus_frame
= frame
;
1479 if (old_focus
&& old_focus
->auto_lower
)
1480 x_lower_frame (old_focus
);
1483 selected_frame
= frame
;
1484 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
1486 Fselect_window (selected_frame
->selected_window
);
1487 choose_minibuf_frame ();
1490 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
1491 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
1493 pending_autoraise_frame
= 0;
1496 x_frame_rehighlight (dpyinfo
);
1499 /* Handle an event saying the mouse has moved out of an Emacs frame. */
1502 x_mouse_leave (dpyinfo
)
1503 struct x_display_info
*dpyinfo
;
1505 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
1508 /* The focus has changed, or we have redirected a frame's focus to
1509 another frame (this happens when a frame uses a surrogate
1510 minibuffer frame). Shift the highlight as appropriate.
1512 The FRAME argument doesn't necessarily have anything to do with which
1513 frame is being highlighted or unhighlighted; we only use it to find
1514 the appropriate X display info. */
1516 XTframe_rehighlight (frame
)
1517 struct frame
*frame
;
1519 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
1523 x_frame_rehighlight (dpyinfo
)
1524 struct x_display_info
*dpyinfo
;
1526 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
1528 if (dpyinfo
->x_focus_frame
)
1530 dpyinfo
->x_highlight_frame
1531 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
1532 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
1533 : dpyinfo
->x_focus_frame
);
1534 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
1536 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
1537 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
1541 dpyinfo
->x_highlight_frame
= 0;
1543 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
1546 frame_unhighlight (old_highlight
);
1547 if (dpyinfo
->x_highlight_frame
)
1548 frame_highlight (dpyinfo
->x_highlight_frame
);
1552 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
1554 /* Initialize mode_switch_bit and modifier_meaning. */
1556 x_find_modifier_meanings (dpyinfo
)
1557 struct x_display_info
*dpyinfo
;
1559 int min_code
, max_code
;
1562 XModifierKeymap
*mods
;
1564 dpyinfo
->meta_mod_mask
= 0;
1565 dpyinfo
->shift_lock_mask
= 0;
1566 dpyinfo
->alt_mod_mask
= 0;
1567 dpyinfo
->super_mod_mask
= 0;
1568 dpyinfo
->hyper_mod_mask
= 0;
1571 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
1573 min_code
= dpyinfo
->display
->min_keycode
;
1574 max_code
= dpyinfo
->display
->max_keycode
;
1577 syms
= XGetKeyboardMapping (dpyinfo
->display
,
1578 min_code
, max_code
- min_code
+ 1,
1580 mods
= XGetModifierMapping (dpyinfo
->display
);
1582 /* Scan the modifier table to see which modifier bits the Meta and
1583 Alt keysyms are on. */
1585 int row
, col
; /* The row and column in the modifier table. */
1587 for (row
= 3; row
< 8; row
++)
1588 for (col
= 0; col
< mods
->max_keypermod
; col
++)
1591 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
1593 /* Zeroes are used for filler. Skip them. */
1597 /* Are any of this keycode's keysyms a meta key? */
1601 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
1603 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
1609 dpyinfo
->meta_mod_mask
|= (1 << row
);
1614 dpyinfo
->alt_mod_mask
|= (1 << row
);
1619 dpyinfo
->hyper_mod_mask
|= (1 << row
);
1624 dpyinfo
->super_mod_mask
|= (1 << row
);
1628 /* Ignore this if it's not on the lock modifier. */
1629 if ((1 << row
) == LockMask
)
1630 dpyinfo
->shift_lock_mask
= LockMask
;
1638 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
1639 if (! dpyinfo
->meta_mod_mask
)
1641 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
1642 dpyinfo
->alt_mod_mask
= 0;
1645 /* If some keys are both alt and meta,
1646 make them just meta, not alt. */
1647 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
1649 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
1652 XFree ((char *) syms
);
1653 XFreeModifiermap (mods
);
1656 /* Convert between the modifier bits X uses and the modifier bits
1659 x_x_to_emacs_modifiers (dpyinfo
, state
)
1660 struct x_display_info
*dpyinfo
;
1663 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
1664 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
1665 | ((state
& dpyinfo
->meta_mod_mask
) ? meta_modifier
: 0)
1666 | ((state
& dpyinfo
->alt_mod_mask
) ? alt_modifier
: 0)
1667 | ((state
& dpyinfo
->super_mod_mask
) ? super_modifier
: 0)
1668 | ((state
& dpyinfo
->hyper_mod_mask
) ? hyper_modifier
: 0));
1672 x_emacs_to_x_modifiers (dpyinfo
, state
)
1673 struct x_display_info
*dpyinfo
;
1676 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
1677 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
1678 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
1679 | ((state
& shift_modifier
) ? ShiftMask
: 0)
1680 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
1681 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
1684 /* Convert a keysym to its name. */
1687 x_get_keysym_name (keysym
)
1693 value
= XKeysymToString (keysym
);
1699 /* Mouse clicks and mouse movement. Rah. */
1701 /* Given a pixel position (PIX_X, PIX_Y) on the frame F, return
1702 glyph co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle
1703 that the glyph at X, Y occupies, if BOUNDS != 0.
1704 If NOCLIP is nonzero, do not force the value into range. */
1707 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
1709 register int pix_x
, pix_y
;
1710 register int *x
, *y
;
1714 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
1715 even for negative values. */
1717 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
1719 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
1721 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
1722 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
1726 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
1727 bounds
->height
= f
->output_data
.x
->line_height
;
1728 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
1729 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
1736 else if (pix_x
> f
->width
)
1741 else if (pix_y
> f
->height
)
1750 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
1753 register int *pix_x
, *pix_y
;
1755 *pix_x
= CHAR_TO_PIXEL_COL (f
, x
);
1756 *pix_y
= CHAR_TO_PIXEL_ROW (f
, y
);
1759 /* Prepare a mouse-event in *RESULT for placement in the input queue.
1761 If the event is a button press, then note that we have grabbed
1765 construct_mouse_click (result
, event
, f
)
1766 struct input_event
*result
;
1767 XButtonEvent
*event
;
1770 /* Make the event type no_event; we'll change that when we decide
1772 result
->kind
= mouse_click
;
1773 result
->code
= event
->button
- Button1
;
1774 result
->timestamp
= event
->time
;
1775 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
1777 | (event
->type
== ButtonRelease
1785 pixel_to_glyph_coords (f
, event
->x
, event
->y
, &column
, &row
, NULL
, 0);
1786 XSETFASTINT (result
->x
, column
);
1787 XSETFASTINT (result
->y
, row
);
1789 XSETINT (result
->x
, event
->x
);
1790 XSETINT (result
->y
, event
->y
);
1791 XSETFRAME (result
->frame_or_window
, f
);
1795 /* Prepare a menu-event in *RESULT for placement in the input queue. */
1798 construct_menu_click (result
, event
, f
)
1799 struct input_event
*result
;
1800 XButtonEvent
*event
;
1803 /* Make the event type no_event; we'll change that when we decide
1805 result
->kind
= mouse_click
;
1806 XSETINT (result
->code
, event
->button
- Button1
);
1807 result
->timestamp
= event
->time
;
1808 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
1810 | (event
->type
== ButtonRelease
1814 XSETINT (result
->x
, event
->x
);
1815 XSETINT (result
->y
, -1);
1816 XSETFRAME (result
->frame_or_window
, f
);
1819 /* Function to report a mouse movement to the mainstream Emacs code.
1820 The input handler calls this.
1822 We have received a mouse movement event, which is given in *event.
1823 If the mouse is over a different glyph than it was last time, tell
1824 the mainstream emacs code by setting mouse_moved. If not, ask for
1825 another motion event, so we can check again the next time it moves. */
1828 note_mouse_movement (frame
, event
)
1830 XMotionEvent
*event
;
1832 last_mouse_movement_time
= event
->time
;
1834 if (event
->window
!= FRAME_X_WINDOW (frame
))
1836 frame
->mouse_moved
= 1;
1837 last_mouse_scroll_bar
= Qnil
;
1839 note_mouse_highlight (frame
, -1, -1);
1841 /* Ask for another mouse motion event. */
1844 Window dummy_window
;
1846 XQueryPointer (event
->display
, FRAME_X_WINDOW (frame
),
1847 &dummy_window
, &dummy_window
,
1848 &dummy
, &dummy
, &dummy
, &dummy
,
1849 (unsigned int *) &dummy
);
1853 /* Has the mouse moved off the glyph it was on at the last sighting? */
1854 else if (event
->x
< last_mouse_glyph
.x
1855 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
1856 || event
->y
< last_mouse_glyph
.y
1857 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
1859 frame
->mouse_moved
= 1;
1860 last_mouse_scroll_bar
= Qnil
;
1862 note_mouse_highlight (frame
, event
->x
, event
->y
);
1864 /* Ask for another mouse motion event. */
1867 Window dummy_window
;
1869 XQueryPointer (event
->display
, FRAME_X_WINDOW (frame
),
1870 &dummy_window
, &dummy_window
,
1871 &dummy
, &dummy
, &dummy
, &dummy
,
1872 (unsigned int *) &dummy
);
1877 /* It's on the same glyph. Call XQueryPointer so we'll get an
1878 event the next time the mouse moves and we can see if it's
1879 *still* on the same glyph. */
1881 Window dummy_window
;
1883 XQueryPointer (event
->display
, FRAME_X_WINDOW (frame
),
1884 &dummy_window
, &dummy_window
,
1885 &dummy
, &dummy
, &dummy
, &dummy
,
1886 (unsigned int *) &dummy
);
1890 /* This is used for debugging, to turn off note_mouse_highlight. */
1891 static int disable_mouse_highlight
;
1893 /* Take proper action when the mouse has moved to position X, Y on frame F
1894 as regards highlighting characters that have mouse-face properties.
1895 Also dehighlighting chars where the mouse was before.
1896 X and Y can be negative or out of range. */
1899 note_mouse_highlight (f
, x
, y
)
1903 int row
, column
, portion
;
1904 XRectangle new_glyph
;
1908 if (disable_mouse_highlight
)
1911 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
= x
;
1912 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
= y
;
1913 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
= f
;
1915 if (FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
)
1920 FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 1;
1924 /* Find out which glyph the mouse is on. */
1925 pixel_to_glyph_coords (f
, x
, y
, &column
, &row
,
1926 &new_glyph
, FRAME_X_DISPLAY_INFO (f
)->grabbed
);
1928 /* Which window is that in? */
1929 window
= window_from_coordinates (f
, column
, row
, &portion
);
1930 w
= XWINDOW (window
);
1932 /* If we were displaying active text in another window, clear that. */
1933 if (! EQ (window
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
))
1934 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1936 /* Are we in a window whose display is up to date?
1937 And verify the buffer's text has not changed. */
1938 if (WINDOWP (window
) && portion
== 0 && row
>= 0 && column
>= 0
1939 && row
< FRAME_HEIGHT (f
) && column
< FRAME_WIDTH (f
)
1940 && EQ (w
->window_end_valid
, w
->buffer
)
1941 && w
->last_modified
== BUF_MODIFF (XBUFFER (w
->buffer
)))
1943 int *ptr
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[row
];
1946 /* Find which buffer position the mouse corresponds to. */
1947 for (i
= column
; i
>= 0; i
--)
1951 /* Is it outside the displayed active region (if any)? */
1953 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1954 else if (! (EQ (window
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
)
1955 && row
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
1956 && row
<= FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
1957 && (row
> FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
1958 || column
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
)
1959 && (row
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
1960 || column
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
1961 || FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
)))
1963 Lisp_Object mouse_face
, overlay
, position
;
1964 Lisp_Object
*overlay_vec
;
1965 int len
, noverlays
, ignor1
;
1966 struct buffer
*obuf
;
1969 /* If we get an out-of-range value, return now; avoid an error. */
1970 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1973 /* Make the window's buffer temporarily current for
1974 overlays_at and compute_char_face. */
1975 obuf
= current_buffer
;
1976 current_buffer
= XBUFFER (w
->buffer
);
1982 /* Yes. Clear the display of the old active region, if any. */
1983 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1985 /* Is this char mouse-active? */
1986 XSETINT (position
, pos
);
1989 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1991 /* Put all the overlays we want in a vector in overlay_vec.
1992 Store the length in len. */
1993 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
1995 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1997 /* Find the highest priority overlay that has a mouse-face prop. */
1999 for (i
= 0; i
< noverlays
; i
++)
2001 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
2002 if (!NILP (mouse_face
))
2004 overlay
= overlay_vec
[i
];
2009 /* If no overlay applies, get a text property. */
2011 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
2013 /* Handle the overlay case. */
2014 if (! NILP (overlay
))
2016 /* Find the range of text around this char that
2017 should be active. */
2018 Lisp_Object before
, after
;
2021 before
= Foverlay_start (overlay
);
2022 after
= Foverlay_end (overlay
);
2023 /* Record this as the current active region. */
2024 fast_find_position (window
, before
,
2025 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
,
2026 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
);
2027 FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
2028 = !fast_find_position (window
, after
,
2029 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
,
2030 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
);
2031 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= window
;
2032 FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
2033 = compute_char_face (f
, w
, pos
, 0, 0,
2034 &ignore
, pos
+ 1, 1);
2036 /* Display it as active. */
2037 show_mouse_face (FRAME_X_DISPLAY_INFO (f
), 1);
2039 /* Handle the text property case. */
2040 else if (! NILP (mouse_face
))
2042 /* Find the range of text around this char that
2043 should be active. */
2044 Lisp_Object before
, after
, beginning
, end
;
2047 beginning
= Fmarker_position (w
->start
);
2048 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
2049 - XFASTINT (w
->window_end_pos
)));
2051 = Fprevious_single_property_change (make_number (pos
+ 1),
2053 w
->buffer
, beginning
);
2055 = Fnext_single_property_change (position
, Qmouse_face
,
2057 /* Record this as the current active region. */
2058 fast_find_position (window
, before
,
2059 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
,
2060 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
);
2061 FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
2062 = !fast_find_position (window
, after
,
2063 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
,
2064 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
);
2065 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= window
;
2066 FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
2067 = compute_char_face (f
, w
, pos
, 0, 0,
2068 &ignore
, pos
+ 1, 1);
2070 /* Display it as active. */
2071 show_mouse_face (FRAME_X_DISPLAY_INFO (f
), 1);
2075 current_buffer
= obuf
;
2080 /* Find the row and column of position POS in window WINDOW.
2081 Store them in *COLUMNP and *ROWP.
2082 This assumes display in WINDOW is up to date.
2083 If POS is above start of WINDOW, return coords
2084 of start of first screen line.
2085 If POS is after end of WINDOW, return coords of end of last screen line.
2087 Value is 1 if POS is in range, 0 if it was off screen. */
2090 fast_find_position (window
, pos
, columnp
, rowp
)
2093 int *columnp
, *rowp
;
2095 struct window
*w
= XWINDOW (window
);
2096 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2101 int height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
2102 int width
= window_internal_width (w
);
2105 int maybe_next_line
= 0;
2107 /* Find the right row. */
2112 int linestart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ i
][left
];
2113 if (linestart
> pos
)
2115 /* If the position sought is the end of the buffer,
2116 don't include the blank lines at the bottom of the window. */
2117 if (linestart
== pos
&& pos
== BUF_ZV (XBUFFER (w
->buffer
)))
2119 maybe_next_line
= 1;
2126 /* Find the right column with in it. */
2127 charstarts
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ row
];
2129 for (i
= 0; i
< width
; i
++)
2131 if (charstarts
[left
+ i
] == pos
)
2134 *columnp
= i
+ left
;
2137 else if (charstarts
[left
+ i
] > pos
)
2139 else if (charstarts
[left
+ i
] > 0)
2143 /* If we're looking for the end of the buffer,
2144 and we didn't find it in the line we scanned,
2145 use the start of the following line. */
2146 if (maybe_next_line
)
2157 /* Display the active region described by mouse_face_*
2158 in its mouse-face if HL > 0, in its normal face if HL = 0. */
2161 show_mouse_face (dpyinfo
, hl
)
2162 struct x_display_info
*dpyinfo
;
2165 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
2166 int width
= window_internal_width (w
);
2167 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2170 int old_curs_x
= curs_x
;
2171 int old_curs_y
= curs_y
;
2173 /* Set these variables temporarily
2174 so that if we have to turn the cursor off and on again
2175 we will put it back at the same place. */
2176 curs_x
= f
->phys_cursor_x
;
2177 curs_y
= f
->phys_cursor_y
;
2179 for (i
= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
;
2180 i
<= FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
; i
++)
2182 int column
= (i
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
2183 ? FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
2185 int endcolumn
= (i
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
2186 ? FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
2188 endcolumn
= min (endcolumn
, FRAME_CURRENT_GLYPHS (f
)->used
[i
]);
2190 /* If the cursor's in the text we are about to rewrite,
2191 turn the cursor off. */
2193 && curs_x
>= column
- 1
2194 && curs_x
<= endcolumn
)
2196 x_display_cursor (f
, 0);
2201 CHAR_TO_PIXEL_COL (f
, column
),
2202 CHAR_TO_PIXEL_ROW (f
, i
),
2203 FRAME_CURRENT_GLYPHS (f
)->glyphs
[i
] + column
,
2205 /* Highlight with mouse face if hl > 0. */
2209 /* If we turned the cursor off, turn it back on. */
2211 x_display_cursor (f
, 1);
2213 curs_x
= old_curs_x
;
2214 curs_y
= old_curs_y
;
2216 /* Change the mouse cursor according to the value of HL. */
2218 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2219 f
->output_data
.x
->cross_cursor
);
2221 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2222 f
->output_data
.x
->text_cursor
);
2225 /* Clear out the mouse-highlighted active region.
2226 Redraw it unhighlighted first. */
2229 clear_mouse_face (dpyinfo
)
2230 struct x_display_info
*dpyinfo
;
2232 if (! NILP (dpyinfo
->mouse_face_window
))
2233 show_mouse_face (dpyinfo
, 0);
2235 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
2236 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
2237 dpyinfo
->mouse_face_window
= Qnil
;
2240 static struct scroll_bar
*x_window_to_scroll_bar ();
2241 static void x_scroll_bar_report_motion ();
2243 /* Return the current position of the mouse.
2244 *fp should be a frame which indicates which display to ask about.
2246 If the mouse movement started in a scroll bar, set *fp, *bar_window,
2247 and *part to the frame, window, and scroll bar part that the mouse
2248 is over. Set *x and *y to the portion and whole of the mouse's
2249 position on the scroll bar.
2251 If the mouse movement started elsewhere, set *fp to the frame the
2252 mouse is on, *bar_window to nil, and *x and *y to the character cell
2255 Set *time to the server timestamp for the time at which the mouse
2256 was at this position.
2258 Don't store anything if we don't have a valid set of values to report.
2260 This clears the mouse_moved flag, so we can wait for the next mouse
2261 movement. This also calls XQueryPointer, which will cause the
2262 server to give us another MotionNotify when the mouse moves
2266 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
2269 Lisp_Object
*bar_window
;
2270 enum scroll_bar_part
*part
;
2272 unsigned long *time
;
2278 if (! NILP (last_mouse_scroll_bar
))
2279 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
2285 Window dummy_window
;
2288 Lisp_Object frame
, tail
;
2290 /* Clear the mouse-moved flag for every frame on this display. */
2291 FOR_EACH_FRAME (tail
, frame
)
2292 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
2293 XFRAME (frame
)->mouse_moved
= 0;
2295 last_mouse_scroll_bar
= Qnil
;
2297 /* Figure out which root window we're on. */
2298 XQueryPointer (FRAME_X_DISPLAY (*fp
),
2299 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
2301 /* The root window which contains the pointer. */
2304 /* Trash which we can't trust if the pointer is on
2305 a different screen. */
2308 /* The position on that root window. */
2311 /* More trash we can't trust. */
2314 /* Modifier keys and pointer buttons, about which
2316 (unsigned int *) &dummy
);
2318 /* Now we have a position on the root; find the innermost window
2319 containing the pointer. */
2323 int parent_x
, parent_y
;
2327 /* XTranslateCoordinates can get errors if the window
2328 structure is changing at the same time this function
2329 is running. So at least we must not crash from them. */
2331 x_catch_errors (FRAME_X_DISPLAY (*fp
));
2333 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
2334 && FRAME_LIVE_P (last_mouse_frame
))
2336 /* If mouse was grabbed on a frame, give coords for that frame
2337 even if the mouse is now outside it. */
2338 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
2340 /* From-window, to-window. */
2341 root
, FRAME_X_WINDOW (last_mouse_frame
),
2343 /* From-position, to-position. */
2344 root_x
, root_y
, &win_x
, &win_y
,
2348 f1
= last_mouse_frame
;
2354 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
2356 /* From-window, to-window. */
2359 /* From-position, to-position. */
2360 root_x
, root_y
, &win_x
, &win_y
,
2365 if (child
== None
|| child
== win
)
2373 /* Now we know that:
2374 win is the innermost window containing the pointer
2375 (XTC says it has no child containing the pointer),
2376 win_x and win_y are the pointer's position in it
2377 (XTC did this the last time through), and
2378 parent_x and parent_y are the pointer's position in win's parent.
2379 (They are what win_x and win_y were when win was child.
2380 If win is the root window, it has no parent, and
2381 parent_{x,y} are invalid, but that's okay, because we'll
2382 never use them in that case.) */
2384 /* Is win one of our frames? */
2385 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
2388 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
2391 x_uncatch_errors (FRAME_X_DISPLAY (*fp
));
2393 /* If not, is it one of our scroll bars? */
2396 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
2400 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2406 if (f1
== 0 && insist
)
2407 f1
= selected_frame
;
2411 int ignore1
, ignore2
;
2413 /* Ok, we found a frame. Store all the values. */
2415 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
2417 FRAME_X_DISPLAY_INFO (f1
)->grabbed
2423 XSETINT (*x
, win_x
);
2424 XSETINT (*y
, win_y
);
2425 *time
= last_mouse_movement_time
;
2433 /* Scroll bar support. */
2435 /* Given an X window ID, find the struct scroll_bar which manages it.
2436 This can be called in GC, so we have to make sure to strip off mark
2438 static struct scroll_bar
*
2439 x_window_to_scroll_bar (window_id
)
2442 Lisp_Object tail
, frame
;
2444 for (tail
= Vframe_list
;
2445 XGCTYPE (tail
) == Lisp_Cons
;
2446 tail
= XCONS (tail
)->cdr
)
2448 Lisp_Object frame
, bar
, condemned
;
2450 frame
= XCONS (tail
)->car
;
2451 /* All elements of Vframe_list should be frames. */
2452 if (! GC_FRAMEP (frame
))
2455 /* Scan this frame's scroll bar list for a scroll bar with the
2457 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
2458 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
2459 /* This trick allows us to search both the ordinary and
2460 condemned scroll bar lists with one loop. */
2461 ! GC_NILP (bar
) || (bar
= condemned
,
2464 bar
= XSCROLL_BAR (bar
)->next
)
2465 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
2466 return XSCROLL_BAR (bar
);
2472 /* Open a new X window to serve as a scroll bar, and return the
2473 scroll bar vector for it. */
2474 static struct scroll_bar
*
2475 x_scroll_bar_create (window
, top
, left
, width
, height
)
2476 struct window
*window
;
2477 int top
, left
, width
, height
;
2479 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2480 struct scroll_bar
*bar
2481 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
2486 XSetWindowAttributes a
;
2488 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
2489 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
2490 | ButtonMotionMask
| PointerMotionHintMask
2492 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
2494 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
2499 XtSetArg (al
[ac
], XtNx
, left
); ac
++;
2500 XtSetArg (al
[ac
], XtNy
, top
); ac
++;
2501 XtSetArg (al
[ac
], XtNwidth
, width
); ac
++;
2502 XtSetArg (al
[ac
], XtNheight
, height
); ac
++;
2503 XtSetArg (al
[ac
], XtNborderWidth
, 0); ac
++;
2504 sb_widget
= XtCreateManagedWidget ("box",
2506 f
->output_data
.x
->edit_widget
, al
, ac
);
2507 SET_SCROLL_BAR_X_WINDOW
2508 (bar
, sb_widget
->core
.window
);
2510 SET_SCROLL_BAR_X_WINDOW
2512 XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2514 /* Position and size of scroll bar. */
2515 left
, top
, width
, height
,
2517 /* Border width, depth, class, and visual. */
2518 0, CopyFromParent
, CopyFromParent
, CopyFromParent
,
2524 XSETWINDOW (bar
->window
, window
);
2525 XSETINT (bar
->top
, top
);
2526 XSETINT (bar
->left
, left
);
2527 XSETINT (bar
->width
, width
);
2528 XSETINT (bar
->height
, height
);
2529 XSETINT (bar
->start
, 0);
2530 XSETINT (bar
->end
, 0);
2531 bar
->dragging
= Qnil
;
2533 /* Add bar to its frame's list of scroll bars. */
2534 bar
->next
= FRAME_SCROLL_BARS (f
);
2536 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2537 if (! NILP (bar
->next
))
2538 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2540 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
2547 /* Draw BAR's handle in the proper position.
2548 If the handle is already drawn from START to END, don't bother
2549 redrawing it, unless REBUILD is non-zero; in that case, always
2550 redraw it. (REBUILD is handy for drawing the handle after expose
2553 Normally, we want to constrain the start and end of the handle to
2554 fit inside its rectangle, but if the user is dragging the scroll bar
2555 handle, we want to let them drag it down all the way, so that the
2556 bar's top is as far down as it goes; otherwise, there's no way to
2557 move to the very end of the buffer. */
2559 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
2560 struct scroll_bar
*bar
;
2564 int dragging
= ! NILP (bar
->dragging
);
2565 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2566 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2567 GC gc
= f
->output_data
.x
->normal_gc
;
2569 /* If the display is already accurate, do nothing. */
2571 && start
== XINT (bar
->start
)
2572 && end
== XINT (bar
->end
))
2578 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (XINT (bar
->width
));
2579 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2580 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2582 /* Make sure the values are reasonable, and try to preserve
2583 the distance between start and end. */
2585 int length
= end
- start
;
2589 else if (start
> top_range
)
2591 end
= start
+ length
;
2595 else if (end
> top_range
&& ! dragging
)
2599 /* Store the adjusted setting in the scroll bar. */
2600 XSETINT (bar
->start
, start
);
2601 XSETINT (bar
->end
, end
);
2603 /* Clip the end position, just for display. */
2604 if (end
> top_range
)
2607 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
2608 below top positions, to make sure the handle is always at least
2609 that many pixels tall. */
2610 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
2612 /* Draw the empty space above the handle. Note that we can't clear
2613 zero-height areas; that means "clear to end of window." */
2615 XClearArea (FRAME_X_DISPLAY (f
), w
,
2617 /* x, y, width, height, and exposures. */
2618 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2619 VERTICAL_SCROLL_BAR_TOP_BORDER
,
2620 inside_width
, start
,
2623 /* Draw the handle itself. */
2624 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
2626 /* x, y, width, height */
2627 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2628 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
2629 inside_width
, end
- start
);
2632 /* Draw the empty space below the handle. Note that we can't
2633 clear zero-height areas; that means "clear to end of window." */
2634 if (end
< inside_height
)
2635 XClearArea (FRAME_X_DISPLAY (f
), w
,
2637 /* x, y, width, height, and exposures. */
2638 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2639 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
2640 inside_width
, inside_height
- end
,
2648 /* Move a scroll bar around on the screen, to accommodate changing
2649 window configurations. */
2651 x_scroll_bar_move (bar
, top
, left
, width
, height
)
2652 struct scroll_bar
*bar
;
2653 int top
, left
, width
, height
;
2655 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2656 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2662 unsigned int mask
= 0;
2669 if (left
!= XINT (bar
->left
)) mask
|= CWX
;
2670 if (top
!= XINT (bar
->top
)) mask
|= CWY
;
2671 if (width
!= XINT (bar
->width
)) mask
|= CWWidth
;
2672 if (height
!= XINT (bar
->height
)) mask
|= CWHeight
;
2675 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
2679 XSETINT (bar
->left
, left
);
2680 XSETINT (bar
->top
, top
);
2681 XSETINT (bar
->width
, width
);
2682 XSETINT (bar
->height
, height
);
2687 /* Destroy the X window for BAR, and set its Emacs window's scroll bar
2690 x_scroll_bar_remove (bar
)
2691 struct scroll_bar
*bar
;
2693 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2697 /* Destroy the window. */
2698 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
2700 /* Disassociate this scroll bar from its window. */
2701 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
2706 /* Set the handle of the vertical scroll bar for WINDOW to indicate
2707 that we are displaying PORTION characters out of a total of WHOLE
2708 characters, starting at POSITION. If WINDOW has no scroll bar,
2711 XTset_vertical_scroll_bar (window
, portion
, whole
, position
)
2712 struct window
*window
;
2713 int portion
, whole
, position
;
2715 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2716 int top
= XINT (window
->top
);
2717 int left
= WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window
);
2718 int height
= WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window
);
2720 /* Where should this scroll bar be, pixelwise? */
2721 int pixel_top
= CHAR_TO_PIXEL_ROW (f
, top
);
2722 int pixel_left
= CHAR_TO_PIXEL_COL (f
, left
);
2724 = (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
2725 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
2726 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
2727 int pixel_height
= VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f
, height
);
2729 struct scroll_bar
*bar
;
2731 /* Does the scroll bar exist yet? */
2732 if (NILP (window
->vertical_scroll_bar
))
2733 bar
= x_scroll_bar_create (window
,
2734 pixel_top
, pixel_left
,
2735 pixel_width
, pixel_height
);
2738 /* It may just need to be moved and resized. */
2739 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2740 x_scroll_bar_move (bar
, pixel_top
, pixel_left
, pixel_width
, pixel_height
);
2743 /* Set the scroll bar's current state, unless we're currently being
2745 if (NILP (bar
->dragging
))
2747 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height
);
2750 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
2753 int start
= ((double) position
* top_range
) / whole
;
2754 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
2756 x_scroll_bar_set_handle (bar
, start
, end
, 0);
2760 XSETVECTOR (window
->vertical_scroll_bar
, bar
);
2764 /* The following three hooks are used when we're doing a thorough
2765 redisplay of the frame. We don't explicitly know which scroll bars
2766 are going to be deleted, because keeping track of when windows go
2767 away is a real pain - "Can you say set-window-configuration, boys
2768 and girls?" Instead, we just assert at the beginning of redisplay
2769 that *all* scroll bars are to be removed, and then save a scroll bar
2770 from the fiery pit when we actually redisplay its window. */
2772 /* Arrange for all scroll bars on FRAME to be removed at the next call
2773 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
2774 `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
2776 XTcondemn_scroll_bars (frame
)
2779 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
2780 while (! NILP (FRAME_SCROLL_BARS (frame
)))
2783 bar
= FRAME_SCROLL_BARS (frame
);
2784 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
2785 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
2786 XSCROLL_BAR (bar
)->prev
= Qnil
;
2787 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
2788 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
2789 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
2793 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
2794 Note that WINDOW isn't necessarily condemned at all. */
2796 XTredeem_scroll_bar (window
)
2797 struct window
*window
;
2799 struct scroll_bar
*bar
;
2801 /* We can't redeem this window's scroll bar if it doesn't have one. */
2802 if (NILP (window
->vertical_scroll_bar
))
2805 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2807 /* Unlink it from the condemned list. */
2809 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2811 if (NILP (bar
->prev
))
2813 /* If the prev pointer is nil, it must be the first in one of
2815 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
2816 /* It's not condemned. Everything's fine. */
2818 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
2819 window
->vertical_scroll_bar
))
2820 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
2822 /* If its prev pointer is nil, it must be at the front of
2823 one or the other! */
2827 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
2829 if (! NILP (bar
->next
))
2830 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
2832 bar
->next
= FRAME_SCROLL_BARS (f
);
2834 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2835 if (! NILP (bar
->next
))
2836 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2840 /* Remove all scroll bars on FRAME that haven't been saved since the
2841 last call to `*condemn_scroll_bars_hook'. */
2843 XTjudge_scroll_bars (f
)
2846 Lisp_Object bar
, next
;
2848 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
2850 /* Clear out the condemned list now so we won't try to process any
2851 more events on the hapless scroll bars. */
2852 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
2854 for (; ! NILP (bar
); bar
= next
)
2856 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
2858 x_scroll_bar_remove (b
);
2861 b
->next
= b
->prev
= Qnil
;
2864 /* Now there should be no references to the condemned scroll bars,
2865 and they should get garbage-collected. */
2869 /* Handle an Expose or GraphicsExpose event on a scroll bar.
2871 This may be called from a signal handler, so we have to ignore GC
2874 x_scroll_bar_expose (bar
, event
)
2875 struct scroll_bar
*bar
;
2878 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2879 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2880 GC gc
= f
->output_data
.x
->normal_gc
;
2884 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
2886 /* Draw a one-pixel border just inside the edges of the scroll bar. */
2887 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
2889 /* x, y, width, height */
2890 0, 0, XINT (bar
->width
) - 1, XINT (bar
->height
) - 1);
2895 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
2896 is set to something other than no_event, it is enqueued.
2898 This may be called from a signal handler, so we have to ignore GC
2901 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
2902 struct scroll_bar
*bar
;
2904 struct input_event
*emacs_event
;
2906 if (! GC_WINDOWP (bar
->window
))
2909 emacs_event
->kind
= scroll_bar_click
;
2910 emacs_event
->code
= event
->xbutton
.button
- Button1
;
2911 emacs_event
->modifiers
2912 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
2913 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
2914 event
->xbutton
.state
)
2915 | (event
->type
== ButtonRelease
2918 emacs_event
->frame_or_window
= bar
->window
;
2919 emacs_event
->timestamp
= event
->xbutton
.time
;
2922 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2924 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2925 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
2928 if (y
> top_range
) y
= top_range
;
2930 if (y
< XINT (bar
->start
))
2931 emacs_event
->part
= scroll_bar_above_handle
;
2932 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
2933 emacs_event
->part
= scroll_bar_handle
;
2935 emacs_event
->part
= scroll_bar_below_handle
;
2937 /* Just because the user has clicked on the handle doesn't mean
2938 they want to drag it. Lisp code needs to be able to decide
2939 whether or not we're dragging. */
2941 /* If the user has just clicked on the handle, record where they're
2943 if (event
->type
== ButtonPress
2944 && emacs_event
->part
== scroll_bar_handle
)
2945 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
2948 /* If the user has released the handle, set it to its final position. */
2949 if (event
->type
== ButtonRelease
2950 && ! NILP (bar
->dragging
))
2952 int new_start
= y
- XINT (bar
->dragging
);
2953 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2955 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2956 bar
->dragging
= Qnil
;
2959 /* Same deal here as the other #if 0. */
2961 /* Clicks on the handle are always reported as occurring at the top of
2963 if (emacs_event
->part
== scroll_bar_handle
)
2964 emacs_event
->x
= bar
->start
;
2966 XSETINT (emacs_event
->x
, y
);
2968 XSETINT (emacs_event
->x
, y
);
2971 XSETINT (emacs_event
->y
, top_range
);
2975 /* Handle some mouse motion while someone is dragging the scroll bar.
2977 This may be called from a signal handler, so we have to ignore GC
2980 x_scroll_bar_note_movement (bar
, event
)
2981 struct scroll_bar
*bar
;
2984 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
2986 last_mouse_movement_time
= event
->xmotion
.time
;
2989 XSETVECTOR (last_mouse_scroll_bar
, bar
);
2991 /* If we're dragging the bar, display it. */
2992 if (! GC_NILP (bar
->dragging
))
2994 /* Where should the handle be now? */
2995 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
2997 if (new_start
!= XINT (bar
->start
))
2999 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
3001 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
3005 /* Call XQueryPointer so we'll get an event the next time the mouse
3006 moves and we can see *still* on the same position. */
3009 Window dummy_window
;
3011 XQueryPointer (event
->xmotion
.display
, event
->xmotion
.window
,
3012 &dummy_window
, &dummy_window
,
3013 &dummy
, &dummy
, &dummy
, &dummy
,
3014 (unsigned int *) &dummy
);
3018 /* Return information to the user about the current position of the mouse
3019 on the scroll bar. */
3021 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
3023 Lisp_Object
*bar_window
;
3024 enum scroll_bar_part
*part
;
3026 unsigned long *time
;
3028 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
3029 Window w
= SCROLL_BAR_X_WINDOW (bar
);
3030 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3032 Window dummy_window
;
3034 unsigned int dummy_mask
;
3038 /* Get the mouse's position relative to the scroll bar window, and
3040 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
3042 /* Root, child, root x and root y. */
3043 &dummy_window
, &dummy_window
,
3044 &dummy_coord
, &dummy_coord
,
3046 /* Position relative to scroll bar. */
3049 /* Mouse buttons and modifier keys. */
3055 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
3057 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
3059 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
3061 if (! NILP (bar
->dragging
))
3062 win_y
-= XINT (bar
->dragging
);
3066 if (win_y
> top_range
)
3070 *bar_window
= bar
->window
;
3072 if (! NILP (bar
->dragging
))
3073 *part
= scroll_bar_handle
;
3074 else if (win_y
< XINT (bar
->start
))
3075 *part
= scroll_bar_above_handle
;
3076 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
3077 *part
= scroll_bar_handle
;
3079 *part
= scroll_bar_below_handle
;
3081 XSETINT (*x
, win_y
);
3082 XSETINT (*y
, top_range
);
3085 last_mouse_scroll_bar
= Qnil
;
3088 *time
= last_mouse_movement_time
;
3094 /* The screen has been cleared so we may have changed foreground or
3095 background colors, and the scroll bars may need to be redrawn.
3096 Clear out the scroll bars, and ask for expose events, so we can
3099 x_scroll_bar_clear (f
)
3104 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
3105 bar
= XSCROLL_BAR (bar
)->next
)
3106 XClearArea (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
3110 /* This processes Expose events from the menubar specific X event
3111 loop in xmenu.c. This allows to redisplay the frame if necessary
3112 when handling menubar or popup items. */
3115 process_expose_from_menu (event
)
3119 struct x_display_info
*dpyinfo
;
3123 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
3124 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
3127 if (f
->async_visible
== 0)
3129 f
->async_visible
= 1;
3130 f
->async_iconified
= 0;
3131 SET_FRAME_GARBAGED (f
);
3135 dumprectangle (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
3136 event
.xexpose
.x
, event
.xexpose
.y
,
3137 event
.xexpose
.width
, event
.xexpose
.height
);
3142 struct scroll_bar
*bar
3143 = x_window_to_scroll_bar (event
.xexpose
.window
);
3146 x_scroll_bar_expose (bar
, &event
);
3152 /* Define a queue to save up SelectionRequest events for later handling. */
3154 struct selection_event_queue
3157 struct selection_event_queue
*next
;
3160 static struct selection_event_queue
*queue
;
3162 /* Nonzero means queue up certain events--don't process them yet. */
3163 static int x_queue_selection_requests
;
3165 /* Queue up an X event *EVENT, to be processed later. */
3168 x_queue_event (f
, event
)
3172 struct selection_event_queue
*queue_tmp
3173 = (struct selection_event_queue
*) malloc (sizeof (struct selection_event_queue
));
3175 if (queue_tmp
!= NULL
)
3177 queue_tmp
->event
= *event
;
3178 queue_tmp
->next
= queue
;
3183 /* Take all the queued events and put them back
3184 so that they get processed afresh. */
3187 x_unqueue_events (display
)
3190 while (queue
!= NULL
)
3192 struct selection_event_queue
*queue_tmp
= queue
;
3193 XPutBackEvent (display
, &queue_tmp
->event
);
3194 queue
= queue_tmp
->next
;
3195 free ((char *)queue_tmp
);
3199 /* Start queuing SelectionRequest events. */
3202 x_start_queuing_selection_requests (display
)
3205 x_queue_selection_requests
++;
3208 /* Stop queuing SelectionRequest events. */
3211 x_stop_queuing_selection_requests (display
)
3214 x_queue_selection_requests
--;
3215 x_unqueue_events (display
);
3218 /* The main X event-reading loop - XTread_socket. */
3220 /* Timestamp of enter window event. This is only used by XTread_socket,
3221 but we have to put it out here, since static variables within functions
3222 sometimes don't work. */
3223 static Time enter_timestamp
;
3225 /* This holds the state XLookupString needs to implement dead keys
3226 and other tricks known as "compose processing". _X Window System_
3227 says that a portable program can't use this, but Stephen Gildea assures
3228 me that letting the compiler initialize it to zeros will work okay.
3230 This must be defined outside of XTread_socket, for the same reasons
3231 given for enter_timestamp, above. */
3232 static XComposeStatus compose_status
;
3234 /* Record the last 100 characters stored
3235 to help debug the loss-of-chars-during-GC problem. */
3236 static int temp_index
;
3237 static short temp_buffer
[100];
3239 /* Set this to nonzero to fake an "X I/O error"
3240 on a particular display. */
3241 struct x_display_info
*XTread_socket_fake_io_error
;
3243 /* When we find no input here, we occasionally do a no-op command
3244 to verify that the X server is still running and we can still talk with it.
3245 We try all the open displays, one by one.
3246 This variable is used for cycling thru the displays. */
3247 static struct x_display_info
*next_noop_dpyinfo
;
3249 /* Read events coming from the X server.
3250 This routine is called by the SIGIO handler.
3251 We return as soon as there are no more events to be read.
3253 Events representing keys are stored in buffer BUFP,
3254 which can hold up to NUMCHARS characters.
3255 We return the number of characters stored into the buffer,
3256 thus pretending to be `read'.
3258 WAITP is nonzero if we should block until input arrives.
3259 EXPECTED is nonzero if the caller knows input is available. */
3262 XTread_socket (sd
, bufp
, numchars
, waitp
, expected
)
3264 register struct input_event
*bufp
;
3265 register int numchars
;
3272 int items_pending
; /* How many items are in the X queue. */
3275 int event_found
= 0;
3278 struct x_display_info
*dpyinfo
;
3280 Status status_return
;
3283 if (interrupt_input_blocked
)
3285 interrupt_input_pending
= 1;
3289 interrupt_input_pending
= 0;
3292 /* So people can tell when we have read the available input. */
3293 input_signal_count
++;
3296 abort (); /* Don't think this happens. */
3298 /* Find the display we are supposed to read input for.
3299 It's the one communicating on descriptor SD. */
3300 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
3302 #if 0 /* This ought to be unnecessary; let's verify it. */
3304 /* If available, Xlib uses FIOSNBIO to make the socket
3305 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
3306 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
3307 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
3308 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
3309 #endif /* ! defined (FIOSNBIO) */
3312 #if 0 /* This code can't be made to work, with multiple displays,
3313 and appears not to be used on any system any more.
3314 Also keyboard.c doesn't turn O_NDELAY on and off
3315 for X connections. */
3318 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
3320 extern int read_alarm_should_throw
;
3321 read_alarm_should_throw
= 1;
3322 XPeekEvent (dpyinfo
->display
, &event
);
3323 read_alarm_should_throw
= 0;
3325 #endif /* HAVE_SELECT */
3329 /* For debugging, this gives a way to fake an I/O error. */
3330 if (dpyinfo
== XTread_socket_fake_io_error
)
3332 XTread_socket_fake_io_error
= 0;
3333 x_io_error_quitter (dpyinfo
->display
);
3336 while (XPending (dpyinfo
->display
) != 0)
3338 XNextEvent (dpyinfo
->display
, &event
);
3345 if (event
.xclient
.message_type
3346 == dpyinfo
->Xatom_wm_protocols
3347 && event
.xclient
.format
== 32)
3349 if (event
.xclient
.data
.l
[0]
3350 == dpyinfo
->Xatom_wm_take_focus
)
3352 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
3353 /* Since we set WM_TAKE_FOCUS, we must call
3354 XSetInputFocus explicitly. But not if f is null,
3355 since that might be an event for a deleted frame. */
3357 /* Not quite sure this is needed -pd */
3359 XSetICFocus (FRAME_XIC (f
));
3362 XSetInputFocus (event
.xclient
.display
,
3363 event
.xclient
.window
,
3364 RevertToPointerRoot
,
3365 event
.xclient
.data
.l
[1]);
3366 /* Not certain about handling scroll bars here */
3368 else if (event
.xclient
.data
.l
[0]
3369 == dpyinfo
->Xatom_wm_save_yourself
)
3371 /* Save state modify the WM_COMMAND property to
3372 something which can reinstate us. This notifies
3373 the session manager, who's looking for such a
3374 PropertyNotify. Can restart processing when
3375 a keyboard or mouse event arrives. */
3378 f
= x_top_window_to_frame (dpyinfo
,
3379 event
.xclient
.window
);
3381 /* This is just so we only give real data once
3382 for a single Emacs process. */
3383 if (f
== selected_frame
)
3384 XSetCommand (FRAME_X_DISPLAY (f
),
3385 event
.xclient
.window
,
3386 initial_argv
, initial_argc
);
3388 XSetCommand (FRAME_X_DISPLAY (f
),
3389 event
.xclient
.window
,
3393 else if (event
.xclient
.data
.l
[0]
3394 == dpyinfo
->Xatom_wm_delete_window
)
3397 = x_any_window_to_frame (dpyinfo
,
3398 event
.xclient
.window
);
3405 bufp
->kind
= delete_window_event
;
3406 XSETFRAME (bufp
->frame_or_window
, f
);
3414 else if (event
.xclient
.message_type
3415 == dpyinfo
->Xatom_wm_configure_denied
)
3418 else if (event
.xclient
.message_type
3419 == dpyinfo
->Xatom_wm_window_moved
)
3423 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
3425 new_x
= event
.xclient
.data
.s
[0];
3426 new_y
= event
.xclient
.data
.s
[1];
3430 f
->output_data
.x
->left_pos
= new_x
;
3431 f
->output_data
.x
->top_pos
= new_y
;
3435 else if (event
.xclient
.message_type
3436 == dpyinfo
->Xatom_editres
)
3439 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
3440 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
3443 #endif /* HACK_EDITRES */
3447 case SelectionNotify
:
3448 #ifdef USE_X_TOOLKIT
3449 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
3451 #endif /* not USE_X_TOOLKIT */
3452 x_handle_selection_notify (&event
);
3455 case SelectionClear
: /* Someone has grabbed ownership. */
3456 #ifdef USE_X_TOOLKIT
3457 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
3459 #endif /* USE_X_TOOLKIT */
3461 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
3466 bufp
->kind
= selection_clear_event
;
3467 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3468 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3469 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3470 bufp
->frame_or_window
= Qnil
;
3478 case SelectionRequest
: /* Someone wants our selection. */
3479 #ifdef USE_X_TOOLKIT
3480 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
3482 #endif /* USE_X_TOOLKIT */
3483 if (x_queue_selection_requests
)
3484 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
3488 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
3493 bufp
->kind
= selection_request_event
;
3494 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3495 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
3496 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3497 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
3498 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
3499 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3500 bufp
->frame_or_window
= Qnil
;
3508 case PropertyNotify
:
3509 #ifdef USE_X_TOOLKIT
3510 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
3512 #endif /* not USE_X_TOOLKIT */
3513 x_handle_property_notify (&event
);
3516 case ReparentNotify
:
3517 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
3521 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
3522 x_real_positions (f
, &x
, &y
);
3523 f
->output_data
.x
->left_pos
= x
;
3524 f
->output_data
.x
->top_pos
= y
;
3529 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
3532 if (f
->async_visible
== 0)
3534 f
->async_visible
= 1;
3535 f
->async_iconified
= 0;
3536 SET_FRAME_GARBAGED (f
);
3539 dumprectangle (x_window_to_frame (dpyinfo
,
3540 event
.xexpose
.window
),
3541 event
.xexpose
.x
, event
.xexpose
.y
,
3542 event
.xexpose
.width
, event
.xexpose
.height
);
3546 struct scroll_bar
*bar
3547 = x_window_to_scroll_bar (event
.xexpose
.window
);
3550 x_scroll_bar_expose (bar
, &event
);
3551 #ifdef USE_X_TOOLKIT
3554 #endif /* USE_X_TOOLKIT */
3558 case GraphicsExpose
: /* This occurs when an XCopyArea's
3559 source area was obscured or not
3561 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
3565 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
3566 event
.xgraphicsexpose
.width
,
3567 event
.xgraphicsexpose
.height
);
3569 #ifdef USE_X_TOOLKIT
3572 #endif /* USE_X_TOOLKIT */
3575 case NoExpose
: /* This occurs when an XCopyArea's
3576 source area was completely
3581 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
3582 if (f
) /* F may no longer exist if
3583 the frame was deleted. */
3585 /* While a frame is unmapped, display generation is
3586 disabled; you don't want to spend time updating a
3587 display that won't ever be seen. */
3588 f
->async_visible
= 0;
3589 /* We can't distinguish, from the event, whether the window
3590 has become iconified or invisible. So assume, if it
3591 was previously visible, than now it is iconified.
3592 We depend on x_make_frame_invisible to mark it iconified. */
3593 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
3594 f
->async_iconified
= 1;
3596 bufp
->kind
= iconify_event
;
3597 XSETFRAME (bufp
->frame_or_window
, f
);
3605 /* We use x_top_window_to_frame because map events can come
3606 for subwindows and they don't mean that the frame is visible. */
3607 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
3610 f
->async_visible
= 1;
3611 f
->async_iconified
= 0;
3613 /* wait_reading_process_input will notice this and update
3614 the frame's display structures. */
3615 SET_FRAME_GARBAGED (f
);
3619 bufp
->kind
= deiconify_event
;
3620 XSETFRAME (bufp
->frame_or_window
, f
);
3626 /* Force a redisplay sooner or later
3627 to update the frame titles
3628 in case this is the second frame. */
3629 record_asynch_buffer_change ();
3633 /* Turn off processing if we become fully obscured. */
3634 case VisibilityNotify
:
3638 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
3642 KeySym keysym
, orig_keysym
;
3643 /* al%imercury@uunet.uu.net says that making this 81 instead of
3644 80 fixed a bug whereby meta chars made his Emacs hang. */
3645 unsigned char copy_buffer
[81];
3649 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
3650 extra_keyboard_modifiers
);
3651 modifiers
= event
.xkey
.state
;
3653 /* This will have to go some day... */
3655 /* make_lispy_event turns chars into control chars.
3656 Don't do it here because XLookupString is too eager. */
3657 event
.xkey
.state
&= ~ControlMask
;
3658 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
3659 | dpyinfo
->super_mod_mask
3660 | dpyinfo
->hyper_mod_mask
3661 | dpyinfo
->alt_mod_mask
);
3666 /* The necessity of the following line took me
3667 a full work-day to decipher from the docs!! */
3668 if (XFilterEvent (&event
, None
))
3670 nbytes
= XmbLookupString (FRAME_XIC (f
),
3671 &event
.xkey
, copy_buffer
,
3676 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
3677 80, &keysym
, &compose_status
);
3679 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
3680 80, &keysym
, &compose_status
);
3683 orig_keysym
= keysym
;
3687 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
3688 || keysym
== XK_Delete
3689 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
3690 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
3692 /* This recognizes the "extended function keys".
3693 It seems there's no cleaner way.
3694 Test IsModifierKey to avoid handling mode_switch
3696 || ((unsigned) (keysym
) >= XK_Select
3697 && (unsigned)(keysym
) < XK_KP_Space
)
3699 #ifdef XK_dead_circumflex
3700 || orig_keysym
== XK_dead_circumflex
3702 #ifdef XK_dead_grave
3703 || orig_keysym
== XK_dead_grave
3705 #ifdef XK_dead_tilde
3706 || orig_keysym
== XK_dead_tilde
3708 #ifdef XK_dead_diaeresis
3709 || orig_keysym
== XK_dead_diaeresis
3711 #ifdef XK_dead_macron
3712 || orig_keysym
== XK_dead_macron
3714 #ifdef XK_dead_degree
3715 || orig_keysym
== XK_dead_degree
3717 #ifdef XK_dead_acute
3718 || orig_keysym
== XK_dead_acute
3720 #ifdef XK_dead_cedilla
3721 || orig_keysym
== XK_dead_cedilla
3723 #ifdef XK_dead_breve
3724 || orig_keysym
== XK_dead_breve
3726 #ifdef XK_dead_ogonek
3727 || orig_keysym
== XK_dead_ogonek
3729 #ifdef XK_dead_caron
3730 || orig_keysym
== XK_dead_caron
3732 #ifdef XK_dead_doubleacute
3733 || orig_keysym
== XK_dead_doubleacute
3735 #ifdef XK_dead_abovedot
3736 || orig_keysym
== XK_dead_abovedot
3738 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
3739 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
3740 /* Any "vendor-specific" key is ok. */
3741 || (orig_keysym
& (1 << 28)))
3742 && ! (IsModifierKey (orig_keysym
)
3744 #ifdef XK_Mode_switch
3745 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
3748 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
3750 #endif /* not HAVE_X11R5 */
3753 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3755 temp_buffer
[temp_index
++] = keysym
;
3756 bufp
->kind
= non_ascii_keystroke
;
3757 bufp
->code
= keysym
;
3758 XSETFRAME (bufp
->frame_or_window
, f
);
3760 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3762 bufp
->timestamp
= event
.xkey
.time
;
3767 else if (numchars
> nbytes
)
3771 for (i
= 0; i
< nbytes
; i
++)
3773 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3775 temp_buffer
[temp_index
++] = copy_buffer
[i
];
3776 bufp
->kind
= ascii_keystroke
;
3777 bufp
->code
= copy_buffer
[i
];
3778 XSETFRAME (bufp
->frame_or_window
, f
);
3780 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3782 bufp
->timestamp
= event
.xkey
.time
;
3797 /* Here's a possible interpretation of the whole
3798 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If you get a
3799 FocusIn event, you have to get a FocusOut event before you
3800 relinquish the focus. If you haven't received a FocusIn event,
3801 then a mere LeaveNotify is enough to free you. */
3804 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
3806 if (event
.xcrossing
.focus
) /* Entered Window */
3808 /* Avoid nasty pop/raise loops. */
3809 if (f
&& (!(f
->auto_raise
)
3811 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
3813 x_new_focus_frame (dpyinfo
, f
);
3814 enter_timestamp
= event
.xcrossing
.time
;
3817 else if (f
== dpyinfo
->x_focus_frame
)
3818 x_new_focus_frame (dpyinfo
, 0);
3819 /* EnterNotify counts as mouse movement,
3820 so update things that depend on mouse position. */
3822 note_mouse_movement (f
, &event
.xmotion
);
3826 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
3827 if (event
.xfocus
.detail
!= NotifyPointer
)
3828 dpyinfo
->x_focus_event_frame
= f
;
3830 x_new_focus_frame (dpyinfo
, f
);
3833 if (f
&& FRAME_XIC (f
))
3834 XSetICFocus (FRAME_XIC (f
));
3840 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
3843 if (f
== dpyinfo
->mouse_face_mouse_frame
)
3844 /* If we move outside the frame,
3845 then we're certainly no longer on any text in the frame. */
3846 clear_mouse_face (dpyinfo
);
3848 if (event
.xcrossing
.focus
)
3849 x_mouse_leave (dpyinfo
);
3852 if (f
== dpyinfo
->x_focus_event_frame
)
3853 dpyinfo
->x_focus_event_frame
= 0;
3854 if (f
== dpyinfo
->x_focus_frame
)
3855 x_new_focus_frame (dpyinfo
, 0);
3861 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
3862 if (event
.xfocus
.detail
!= NotifyPointer
3863 && f
== dpyinfo
->x_focus_event_frame
)
3864 dpyinfo
->x_focus_event_frame
= 0;
3865 if (f
&& f
== dpyinfo
->x_focus_frame
)
3866 x_new_focus_frame (dpyinfo
, 0);
3869 if (f
&& FRAME_XIC (f
))
3870 XUnsetICFocus (FRAME_XIC (f
));
3877 if (dpyinfo
->grabbed
&& last_mouse_frame
3878 && FRAME_LIVE_P (last_mouse_frame
))
3879 f
= last_mouse_frame
;
3881 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
3883 note_mouse_movement (f
, &event
.xmotion
);
3886 struct scroll_bar
*bar
3887 = x_window_to_scroll_bar (event
.xmotion
.window
);
3890 x_scroll_bar_note_movement (bar
, &event
);
3892 /* If we move outside the frame,
3893 then we're certainly no longer on any text in the frame. */
3894 clear_mouse_face (dpyinfo
);
3899 case ConfigureNotify
:
3900 f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
3902 #ifdef USE_X_TOOLKIT
3903 && (event
.xconfigure
.window
== XtWindow (f
->output_data
.x
->widget
))
3907 #ifndef USE_X_TOOLKIT
3908 /* In the toolkit version, change_frame_size
3909 is called by the code that handles resizing
3910 of the EmacsFrame widget. */
3912 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
3913 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
3915 /* Even if the number of character rows and columns has
3916 not changed, the font size may have changed, so we need
3917 to check the pixel dimensions as well. */
3918 if (columns
!= f
->width
3919 || rows
!= f
->height
3920 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
3921 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
3923 change_frame_size (f
, rows
, columns
, 0, 1);
3924 SET_FRAME_GARBAGED (f
);
3928 /* Formerly, in the USE_X_TOOLKIT version,
3929 we did not test send_event here. */
3931 #ifndef USE_X_TOOLKIT
3932 && ! event
.xconfigure
.send_event
3939 /* Find the position of the outside upper-left corner of
3940 the window, in the root coordinate system. Don't
3941 refer to the parent window here; we may be processing
3942 this event after the window manager has changed our
3943 parent, but before we have reached the ReparentNotify. */
3944 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3946 /* From-window, to-window. */
3947 event
.xconfigure
.window
,
3948 FRAME_X_DISPLAY_INFO (f
)->root_window
,
3950 /* From-position, to-position. */
3951 -event
.xconfigure
.border_width
,
3952 -event
.xconfigure
.border_width
,
3957 event
.xconfigure
.x
= win_x
;
3958 event
.xconfigure
.y
= win_y
;
3961 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
3962 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
3963 f
->output_data
.x
->left_pos
= event
.xconfigure
.x
;
3964 f
->output_data
.x
->top_pos
= event
.xconfigure
.y
;
3966 /* What we have now is the position of Emacs's own window.
3967 Convert that to the position of the window manager window. */
3970 x_real_positions (f
, &x
, &y
);
3971 f
->output_data
.x
->left_pos
= x
;
3972 f
->output_data
.x
->top_pos
= y
;
3973 /* Formerly we did not do this in the USE_X_TOOLKIT
3974 version. Let's try making them the same. */
3975 /* #ifndef USE_X_TOOLKIT */
3976 if (y
!= event
.xconfigure
.y
)
3978 /* Since the WM decorations come below top_pos now,
3979 we must put them below top_pos in the future. */
3980 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
3981 x_wm_set_size_hint (f
, (long) 0, 0);
3991 /* If we decide we want to generate an event to be seen
3992 by the rest of Emacs, we put it here. */
3993 struct input_event emacs_event
;
3994 emacs_event
.kind
= no_event
;
3996 bzero (&compose_status
, sizeof (compose_status
));
3998 if (dpyinfo
->grabbed
&& last_mouse_frame
3999 && FRAME_LIVE_P (last_mouse_frame
))
4000 f
= last_mouse_frame
;
4002 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
4006 if (!dpyinfo
->x_focus_frame
|| f
== dpyinfo
->x_focus_frame
)
4007 construct_mouse_click (&emacs_event
, &event
, f
);
4011 struct scroll_bar
*bar
4012 = x_window_to_scroll_bar (event
.xbutton
.window
);
4015 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
4018 if (event
.type
== ButtonPress
)
4020 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
4021 last_mouse_frame
= f
;
4025 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
4028 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
4030 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
4036 #ifdef USE_X_TOOLKIT
4037 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
4038 /* For a down-event in the menu bar,
4039 don't pass it to Xt right now.
4040 Instead, save it away
4041 and we will pass it to Xt from kbd_buffer_get_event.
4042 That way, we can run some Lisp code first. */
4043 if (f
&& event
.type
== ButtonPress
4044 /* Verify the event is really within the menu bar
4045 and not just sent to it due to grabbing. */
4046 && event
.xbutton
.x
>= 0
4047 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
4048 && event
.xbutton
.y
>= 0
4049 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
4050 && event
.xbutton
.same_screen
)
4052 if (f
->output_data
.x
->saved_button_event
== 0)
4053 f
->output_data
.x
->saved_button_event
4054 = (XButtonEvent
*) xmalloc (sizeof (XButtonEvent
));
4055 bcopy (&event
, f
->output_data
.x
->saved_button_event
,
4056 sizeof (XButtonEvent
));
4059 bufp
->kind
= menu_bar_activate_event
;
4060 XSETFRAME (bufp
->frame_or_window
, f
);
4068 #endif /* USE_X_TOOLKIT */
4072 case CirculateNotify
:
4074 case CirculateRequest
:
4078 /* Someone has changed the keyboard mapping - update the
4080 switch (event
.xmapping
.request
)
4082 case MappingModifier
:
4083 x_find_modifier_meanings (dpyinfo
);
4084 /* This is meant to fall through. */
4085 case MappingKeyboard
:
4086 XRefreshKeyboardMapping (&event
.xmapping
);
4092 #ifdef USE_X_TOOLKIT
4094 XtDispatchEvent (&event
);
4096 #endif /* USE_X_TOOLKIT */
4102 /* On some systems, an X bug causes Emacs to get no more events
4103 when the window is destroyed. Detect that. (1994.) */
4106 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
4107 One XNOOP in 100 loops will make Emacs terminate.
4108 B. Bretthauer, 1994 */
4110 if (x_noop_count
>= 100)
4114 if (next_noop_dpyinfo
== 0)
4115 next_noop_dpyinfo
= x_display_list
;
4117 XNoOp (next_noop_dpyinfo
->display
);
4119 /* Each time we get here, cycle through the displays now open. */
4120 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
4124 /* If the focus was just given to an autoraising frame,
4126 /* ??? This ought to be able to handle more than one such frame. */
4127 if (pending_autoraise_frame
)
4129 x_raise_frame (pending_autoraise_frame
);
4130 pending_autoraise_frame
= 0;
4137 /* Drawing the cursor. */
4140 /* Draw a hollow box cursor on frame F at X, Y.
4141 Don't change the inside of the box. */
4144 x_draw_box (f
, x
, y
)
4148 int left
= CHAR_TO_PIXEL_COL (f
, x
);
4149 int top
= CHAR_TO_PIXEL_ROW (f
, y
);
4150 int width
= FONT_WIDTH (f
->output_data
.x
->font
);
4151 int height
= f
->output_data
.x
->line_height
;
4153 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4154 f
->output_data
.x
->cursor_gc
,
4155 left
, top
, width
- 1, height
- 1);
4158 /* Clear the cursor of frame F to background color,
4159 and mark the cursor as not shown.
4160 This is used when the text where the cursor is
4161 is about to be rewritten. */
4169 if (! FRAME_VISIBLE_P (f
)
4170 || f
->phys_cursor_x
< 0)
4173 x_display_cursor (f
, 0);
4174 f
->phys_cursor_x
= -1;
4177 /* Redraw the glyph at ROW, COLUMN on frame F, in the style
4178 HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
4182 x_draw_single_glyph (f
, row
, column
, glyph
, highlight
)
4189 CHAR_TO_PIXEL_COL (f
, column
),
4190 CHAR_TO_PIXEL_ROW (f
, row
),
4191 &glyph
, 1, highlight
, 0);
4195 x_display_bar_cursor (f
, on
, x
, y
)
4200 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4202 /* This is pointless on invisible frames, and dangerous on garbaged
4203 frames; in the latter case, the frame may be in the midst of
4204 changing its size, and x and y may be off the frame. */
4205 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4208 if (! on
&& f
->phys_cursor_x
< 0)
4211 /* If there is anything wrong with the current cursor state, remove it. */
4212 if (f
->phys_cursor_x
>= 0
4214 || f
->phys_cursor_x
!= x
4215 || f
->phys_cursor_y
!= y
4216 || f
->output_data
.x
->current_cursor
!= bar_cursor
))
4218 /* Erase the cursor by redrawing the character underneath it. */
4219 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4220 f
->phys_cursor_glyph
,
4221 current_glyphs
->highlight
[f
->phys_cursor_y
]);
4222 f
->phys_cursor_x
= -1;
4225 /* If we now need a cursor in the new place or in the new form, do it so. */
4227 && (f
->phys_cursor_x
< 0
4228 || (f
->output_data
.x
->current_cursor
!= bar_cursor
)))
4230 f
->phys_cursor_glyph
4231 = ((current_glyphs
->enable
[y
]
4232 && x
< current_glyphs
->used
[y
])
4233 ? current_glyphs
->glyphs
[y
][x
]
4235 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4236 f
->output_data
.x
->cursor_gc
,
4237 CHAR_TO_PIXEL_COL (f
, x
),
4238 CHAR_TO_PIXEL_ROW (f
, y
),
4239 max (f
->output_data
.x
->cursor_width
, 1),
4240 f
->output_data
.x
->line_height
);
4242 f
->phys_cursor_x
= x
;
4243 f
->phys_cursor_y
= y
;
4245 f
->output_data
.x
->current_cursor
= bar_cursor
;
4248 if (updating_frame
!= f
)
4249 XFlush (FRAME_X_DISPLAY (f
));
4253 /* Turn the displayed cursor of frame F on or off according to ON.
4254 If ON is nonzero, where to put the cursor is specified by X and Y. */
4257 x_display_box_cursor (f
, on
, x
, y
)
4262 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4264 /* This is pointless on invisible frames, and dangerous on garbaged
4265 frames; in the latter case, the frame may be in the midst of
4266 changing its size, and x and y may be off the frame. */
4267 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4270 /* If cursor is off and we want it off, return quickly. */
4271 if (!on
&& f
->phys_cursor_x
< 0)
4274 /* If cursor is currently being shown and we don't want it to be
4275 or it is in the wrong place,
4276 or we want a hollow box and it's not so, (pout!)
4278 if (f
->phys_cursor_x
>= 0
4280 || f
->phys_cursor_x
!= x
4281 || f
->phys_cursor_y
!= y
4282 || (f
->output_data
.x
->current_cursor
!= hollow_box_cursor
4283 && (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
))))
4285 int mouse_face_here
= 0;
4286 struct frame_glyphs
*active_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4288 /* If the cursor is in the mouse face area, redisplay that when
4289 we clear the cursor. */
4290 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
4292 (f
->phys_cursor_y
> FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
4293 || (f
->phys_cursor_y
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
4294 && f
->phys_cursor_x
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
))
4296 (f
->phys_cursor_y
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
4297 || (f
->phys_cursor_y
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
4298 && f
->phys_cursor_x
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
))
4299 /* Don't redraw the cursor's spot in mouse face
4300 if it is at the end of a line (on a newline).
4301 The cursor appears there, but mouse highlighting does not. */
4302 && active_glyphs
->used
[f
->phys_cursor_y
] > f
->phys_cursor_x
)
4303 mouse_face_here
= 1;
4305 /* If the font is not as tall as a whole line,
4306 we must explicitly clear the line's whole height. */
4307 if (FONT_HEIGHT (f
->output_data
.x
->font
) != f
->output_data
.x
->line_height
)
4308 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4309 CHAR_TO_PIXEL_COL (f
, f
->phys_cursor_x
),
4310 CHAR_TO_PIXEL_ROW (f
, f
->phys_cursor_y
),
4311 FONT_WIDTH (f
->output_data
.x
->font
),
4312 f
->output_data
.x
->line_height
, False
);
4313 /* Erase the cursor by redrawing the character underneath it. */
4314 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4315 f
->phys_cursor_glyph
,
4318 : current_glyphs
->highlight
[f
->phys_cursor_y
]));
4319 f
->phys_cursor_x
= -1;
4322 /* If we want to show a cursor,
4323 or we want a box cursor and it's not so,
4324 write it in the right place. */
4326 && (f
->phys_cursor_x
< 0
4327 || (f
->output_data
.x
->current_cursor
!= filled_box_cursor
4328 && f
== FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)))
4330 f
->phys_cursor_glyph
4331 = ((current_glyphs
->enable
[y
]
4332 && x
< current_glyphs
->used
[y
])
4333 ? current_glyphs
->glyphs
[y
][x
]
4335 if (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
4337 x_draw_box (f
, x
, y
);
4338 f
->output_data
.x
->current_cursor
= hollow_box_cursor
;
4342 x_draw_single_glyph (f
, y
, x
,
4343 f
->phys_cursor_glyph
, 2);
4344 f
->output_data
.x
->current_cursor
= filled_box_cursor
;
4347 f
->phys_cursor_x
= x
;
4348 f
->phys_cursor_y
= y
;
4351 if (updating_frame
!= f
)
4352 XFlush (FRAME_X_DISPLAY (f
));
4355 /* Display the cursor on frame F, or clear it, according to ON.
4356 Use the position specified by curs_x and curs_y
4357 if we are doing an update of frame F now.
4358 Otherwise use the position in the FRAME_CURSOR_X and FRAME_CURSOR_Y fields
4361 x_display_cursor (f
, on
)
4367 /* If we're not updating, then don't change the physical cursor
4368 position. Just change (if appropriate) the style of display. */
4369 if (f
!= updating_frame
)
4371 curs_x
= FRAME_CURSOR_X (f
);
4372 curs_y
= FRAME_CURSOR_Y (f
);
4375 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4376 x_display_box_cursor (f
, on
, curs_x
, curs_y
);
4377 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4378 x_display_bar_cursor (f
, on
, curs_x
, curs_y
);
4380 /* Those are the only two we have implemented! */
4386 /* Display the cursor on frame F, or clear it, according to ON.
4387 Don't change the cursor's position. */
4389 x_update_cursor (f
, on
)
4395 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4396 x_display_box_cursor (f
, on
, f
->phys_cursor_x
, f
->phys_cursor_y
);
4397 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4398 x_display_bar_cursor (f
, on
, f
->phys_cursor_x
, f
->phys_cursor_y
);
4400 /* Those are the only two we have implemented! */
4408 /* Refresh bitmap kitchen sink icon for frame F
4409 when we get an expose event for it. */
4414 /* Normally, the window manager handles this function. */
4417 /* Make the x-window of frame F use the gnu icon bitmap. */
4420 x_bitmap_icon (f
, file
)
4424 int mask
, bitmap_id
;
4427 if (FRAME_X_WINDOW (f
) == 0)
4430 /* Free up our existing icon bitmap if any. */
4431 if (f
->output_data
.x
->icon_bitmap
> 0)
4432 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
4433 f
->output_data
.x
->icon_bitmap
= 0;
4436 bitmap_id
= x_create_bitmap_from_file (f
, file
);
4439 /* Create the GNU bitmap if necessary. */
4440 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
4441 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
4442 = x_create_bitmap_from_data (f
, gnu_bits
,
4443 gnu_width
, gnu_height
);
4445 /* The first time we create the GNU bitmap,
4446 this increments the refcount one extra time.
4447 As a result, the GNU bitmap is never freed.
4448 That way, we don't have to worry about allocating it again. */
4449 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
4451 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
4454 x_wm_set_icon_pixmap (f
, bitmap_id
);
4455 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
4461 /* Make the x-window of frame F use a rectangle with text.
4462 Use ICON_NAME as the text. */
4465 x_text_icon (f
, icon_name
)
4469 if (FRAME_X_WINDOW (f
) == 0)
4475 text
.value
= (unsigned char *) icon_name
;
4476 text
.encoding
= XA_STRING
;
4478 text
.nitems
= strlen (icon_name
);
4479 #ifdef USE_X_TOOLKIT
4480 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
4482 #else /* not USE_X_TOOLKIT */
4483 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
4484 #endif /* not USE_X_TOOLKIT */
4486 #else /* not HAVE_X11R4 */
4487 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
4488 #endif /* not HAVE_X11R4 */
4490 if (f
->output_data
.x
->icon_bitmap
> 0)
4491 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
4492 f
->output_data
.x
->icon_bitmap
= 0;
4493 x_wm_set_icon_pixmap (f
, 0);
4498 /* Handling X errors. */
4500 /* Handle the loss of connection to display DISPLAY. */
4503 x_connection_closed (display
, error_message
)
4505 char *error_message
;
4507 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
4508 Lisp_Object frame
, tail
;
4510 /* Whatever we were in the middle of, we are going to throw out of it,
4511 so reassure various things that have error checks about being
4512 called with input blocked. */
4513 TOTALLY_UNBLOCK_INPUT
;
4518 /* First delete frames whose minibuffers are on frames
4519 that are on the dead display. */
4520 FOR_EACH_FRAME (tail
, frame
)
4522 Lisp_Object minibuf_frame
;
4524 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
4525 if (FRAME_X_P (XFRAME (frame
))
4526 && FRAME_X_P (XFRAME (minibuf_frame
))
4527 && ! EQ (frame
, minibuf_frame
)
4528 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
4529 Fdelete_frame (frame
, Qt
);
4532 /* Now delete all remaining frames on the dead display.
4533 We are now sure none of these is used as the minibuffer
4534 for another frame that we need to delete. */
4535 FOR_EACH_FRAME (tail
, frame
)
4536 if (FRAME_X_P (XFRAME (frame
))
4537 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
4539 /* Set this to t so that Fdelete_frame won't get confused
4540 trying to find a replacement. */
4541 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
4542 Fdelete_frame (frame
, Qt
);
4546 x_delete_display (dpyinfo
);
4548 if (x_display_list
== 0)
4550 fprintf (stderr
, "%s", error_message
);
4551 shut_down_emacs (0, 0, Qnil
);
4555 /* Ordinary stack unwind doesn't deal with these. */
4557 sigunblock (sigmask (SIGIO
));
4559 sigunblock (sigmask (SIGALRM
));
4560 TOTALLY_UNBLOCK_INPUT
;
4562 error ("%s", error_message
);
4565 /* This is the usual handler for X protocol errors.
4566 It kills all frames on the display that we got the error for.
4567 If that was the only one, it prints an error message and kills Emacs. */
4570 x_error_quitter (display
, error
)
4574 char buf
[256], buf1
[356];
4576 /* Note that there is no real way portable across R3/R4 to get the
4577 original error handler. */
4579 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
4580 sprintf (buf1
, "X protocol error: %s on protocol request %d",
4581 buf
, error
->request_code
);
4582 x_connection_closed (display
, buf1
);
4585 /* This is the handler for X IO errors, always.
4586 It kills all frames on the display that we lost touch with.
4587 If that was the only one, it prints an error message and kills Emacs. */
4590 x_io_error_quitter (display
)
4595 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
4596 x_connection_closed (display
, buf
);
4599 /* Handle SIGPIPE, which can happen when the connection to a server
4600 simply goes away. SIGPIPE is handled by x_connection_signal.
4601 It works by sending a no-op command to each X server connection.
4602 When we try a connection that has closed, we get SIGPIPE again.
4603 But this time, it is handled by x_connection_signal_1.
4604 That function knows which connection we were testing,
4605 so it closes that one.
4607 x_connection_closed never returns,
4608 so if more than one connection was lost at once,
4609 we only find one. But XTread_socket keeps trying them all,
4610 so it will notice the other closed one sooner or later. */
4613 static struct x_display_info
*x_connection_signal_dpyinfo
;
4615 static SIGTYPE
x_connection_signal ();
4618 x_connection_signal_1 (signalnum
) /* If we don't have an argument, */
4619 int signalnum
; /* some compilers complain in signal calls. */
4621 signal (SIGPIPE
, x_connection_signal
);
4622 x_connection_closed (x_connection_signal_dpyinfo
,
4623 "connection was lost");
4627 x_connection_signal (signalnum
) /* If we don't have an argument, */
4628 int signalnum
; /* some compilers complain in signal calls. */
4630 x_connection_signal_dpyinfo
= x_display_list
;
4633 sigunblock (SIGPIPE
);
4635 while (x_connection_signal_dpyinfo
)
4637 signal (SIGPIPE
, x_connection_signal_1
);
4638 signal (SIGALRM
, x_connection_signal_1
);
4641 #ifdef XlibDisplayWriting
4642 /* If the thread-interlock is locked, assume this connection is dead.
4643 This assumes that the library does not make other threads
4644 that can be locking the display legitimately. */
4645 if (x_connection_signal_dpyinfo
->display
->flags
& XlibDisplayWriting
)
4646 x_connection_closed (x_connection_signal_dpyinfo
,
4647 "connection was lost");
4651 XNoOp (x_connection_signal_dpyinfo
->display
);
4653 XSync (x_connection_signal_dpyinfo
->display
, False
);
4655 /* Each time we get here, cycle through the displays now open. */
4656 x_connection_signal_dpyinfo
= x_connection_signal_dpyinfo
->next
;
4659 /* We should have found some closed connection. */
4663 /* A buffer for storing X error messages. */
4664 static char *x_caught_error_message
;
4665 #define X_CAUGHT_ERROR_MESSAGE_SIZE 200
4667 /* An X error handler which stores the error message in
4668 x_caught_error_message. This is what's installed when
4669 x_catch_errors is in effect. */
4672 x_error_catcher (display
, error
)
4676 XGetErrorText (display
, error
->error_code
,
4677 x_caught_error_message
, X_CAUGHT_ERROR_MESSAGE_SIZE
);
4681 /* Begin trapping X errors for display DPY. Actually we trap X errors
4682 for all displays, but DPY should be the display you are actually
4685 After calling this function, X protocol errors no longer cause
4686 Emacs to exit; instead, they are recorded in x_cfc_error_message.
4688 Calling x_check_errors signals an Emacs error if an X error has
4689 occurred since the last call to x_catch_errors or x_check_errors.
4691 Calling x_uncatch_errors resumes the normal error handling. */
4693 void x_catch_errors (), x_check_errors (), x_uncatch_errors ();
4696 x_catch_errors (dpy
)
4699 /* Make sure any errors from previous requests have been dealt with. */
4702 /* Set up the error buffer. */
4703 x_caught_error_message
4704 = (char*) xmalloc (X_CAUGHT_ERROR_MESSAGE_SIZE
);
4705 x_caught_error_message
[0] = '\0';
4707 /* Install our little error handler. */
4708 XSetErrorHandler (x_error_catcher
);
4711 /* If any X protocol errors have arrived since the last call to
4712 x_catch_errors or x_check_errors, signal an Emacs error using
4713 sprintf (a buffer, FORMAT, the x error message text) as the text. */
4716 x_check_errors (dpy
, format
)
4720 /* Make sure to catch any errors incurred so far. */
4723 if (x_caught_error_message
[0])
4725 char buf
[X_CAUGHT_ERROR_MESSAGE_SIZE
+ 56];
4727 sprintf (buf
, format
, x_caught_error_message
);
4728 x_uncatch_errors (dpy
);
4733 /* Nonzero if we had any X protocol errors since we did x_catch_errors. */
4736 x_had_errors_p (dpy
)
4739 /* Make sure to catch any errors incurred so far. */
4742 return x_caught_error_message
[0] != 0;
4745 /* Stop catching X protocol errors and let them make Emacs die. */
4748 x_uncatch_errors (dpy
)
4751 xfree (x_caught_error_message
);
4752 x_caught_error_message
= 0;
4753 XSetErrorHandler (x_error_quitter
);
4757 static unsigned int x_wire_count
;
4760 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
4765 /* Changing the font of the frame. */
4767 /* Give frame F the font named FONTNAME as its default font, and
4768 return the full name of that font. FONTNAME may be a wildcard
4769 pattern; in that case, we choose some font that fits the pattern.
4770 The return value shows which font we chose. */
4773 x_new_font (f
, fontname
)
4775 register char *fontname
;
4778 int n_matching_fonts
;
4779 XFontStruct
*font_info
;
4782 /* Get a list of all the fonts that match this name. Once we
4783 have a list of matching fonts, we compare them against the fonts
4784 we already have by comparing font ids. */
4785 font_names
= (char **) XListFonts (FRAME_X_DISPLAY (f
), fontname
,
4786 1024, &n_matching_fonts
);
4787 /* Apparently it doesn't set n_matching_fonts to zero when it can't
4788 find any matches; font_names == 0 is the only clue. */
4790 n_matching_fonts
= 0;
4792 /* Don't just give up if n_matching_fonts is 0.
4793 Apparently there's a bug on Suns: XListFontsWithInfo can
4794 fail to find a font, but XLoadQueryFont may still find it. */
4796 /* See if we've already loaded a matching font. */
4797 already_loaded
= -1;
4798 if (n_matching_fonts
!= 0)
4802 for (i
= 0; i
< FRAME_X_DISPLAY_INFO (f
)->n_fonts
; i
++)
4803 for (j
= 0; j
< n_matching_fonts
; j
++)
4804 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].name
, font_names
[j
])
4805 || !strcmp (FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].full_name
, font_names
[j
]))
4808 fontname
= FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].full_name
;
4814 /* If we have, just return it from the table. */
4815 if (already_loaded
>= 0)
4816 f
->output_data
.x
->font
= FRAME_X_DISPLAY_INFO (f
)->font_table
[already_loaded
].font
;
4817 /* Otherwise, load the font and add it to the table. */
4825 /* Try to find a character-cell font in the list. */
4827 /* A laudable goal, but this isn't how to do it. */
4828 for (i
= 0; i
< n_matching_fonts
; i
++)
4829 if (! font_info
[i
].per_char
)
4835 /* See comment above. */
4836 if (n_matching_fonts
!= 0)
4837 fontname
= font_names
[i
];
4839 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
4842 /* Free the information from XListFonts. */
4843 if (n_matching_fonts
)
4844 XFreeFontNames (font_names
);
4848 /* Do we need to create the table? */
4849 if (FRAME_X_DISPLAY_INFO (f
)->font_table_size
== 0)
4851 FRAME_X_DISPLAY_INFO (f
)->font_table_size
= 16;
4852 FRAME_X_DISPLAY_INFO (f
)->font_table
4853 = (struct font_info
*) xmalloc (FRAME_X_DISPLAY_INFO (f
)->font_table_size
4854 * sizeof (struct font_info
));
4856 /* Do we need to grow the table? */
4857 else if (FRAME_X_DISPLAY_INFO (f
)->n_fonts
4858 >= FRAME_X_DISPLAY_INFO (f
)->font_table_size
)
4860 FRAME_X_DISPLAY_INFO (f
)->font_table_size
*= 2;
4861 FRAME_X_DISPLAY_INFO (f
)->font_table
4862 = (struct font_info
*) xrealloc (FRAME_X_DISPLAY_INFO (f
)->font_table
,
4863 (FRAME_X_DISPLAY_INFO (f
)->font_table_size
4864 * sizeof (struct font_info
)));
4867 /* Try to get the full name of FONT. Put it in full_name. */
4869 for (i
= 0; i
< font
->n_properties
; i
++)
4872 = XGetAtomName (FRAME_X_DISPLAY (f
), font
->properties
[i
].name
);
4873 if (!strcmp (atom
, "FONT"))
4875 char *name
= XGetAtomName (FRAME_X_DISPLAY (f
),
4876 (Atom
) (font
->properties
[i
].card32
));
4880 /* Count the number of dashes in the "full name".
4881 If it is too few, this isn't really the font's full name,
4883 In X11R4, the fonts did not come with their canonical names
4901 n_fonts
= FRAME_X_DISPLAY_INFO (f
)->n_fonts
;
4902 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
= (char *) xmalloc (strlen (fontname
) + 1);
4903 bcopy (fontname
, FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
, strlen (fontname
) + 1);
4905 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].full_name
= full_name
;
4907 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].full_name
= FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
;
4908 f
->output_data
.x
->font
= FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].font
= font
;
4909 FRAME_X_DISPLAY_INFO (f
)->n_fonts
++;
4912 fontname
= full_name
;
4915 /* Compute the scroll bar width in character columns. */
4916 if (f
->scroll_bar_pixel_width
> 0)
4918 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
4919 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
4922 f
->scroll_bar_cols
= 2;
4924 /* Now make the frame display the given font. */
4925 if (FRAME_X_WINDOW (f
) != 0)
4927 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
4928 f
->output_data
.x
->font
->fid
);
4929 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
4930 f
->output_data
.x
->font
->fid
);
4931 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
4932 f
->output_data
.x
->font
->fid
);
4934 frame_update_line_height (f
);
4935 x_set_window_size (f
, 0, f
->width
, f
->height
);
4938 /* If we are setting a new frame's font for the first time,
4939 there are no faces yet, so this font's height is the line height. */
4940 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
4943 Lisp_Object lispy_name
;
4945 lispy_name
= build_string (fontname
);
4947 /* Free the information from XListFonts. The data
4948 we actually retain comes from XLoadQueryFont. */
4949 XFreeFontNames (font_names
);
4955 x_calc_absolute_position (f
)
4959 int win_x
= 0, win_y
= 0;
4960 int flags
= f
->output_data
.x
->size_hint_flags
;
4963 #ifdef USE_X_TOOLKIT
4964 this_window
= XtWindow (f
->output_data
.x
->widget
);
4966 this_window
= FRAME_X_WINDOW (f
);
4969 /* Find the position of the outside upper-left corner of
4970 the inner window, with respect to the outer window. */
4971 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
4974 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
4976 /* From-window, to-window. */
4978 f
->output_data
.x
->parent_desc
,
4980 /* From-position, to-position. */
4981 0, 0, &win_x
, &win_y
,
4988 /* Treat negative positions as relative to the leftmost bottommost
4989 position that fits on the screen. */
4990 if (flags
& XNegative
)
4991 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
4992 - 2 * f
->output_data
.x
->border_width
- win_x
4994 + f
->output_data
.x
->left_pos
);
4996 if (flags
& YNegative
)
4997 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
4998 - 2 * f
->output_data
.x
->border_width
- win_y
5000 - (FRAME_EXTERNAL_MENU_BAR (f
)
5001 ? f
->output_data
.x
->menubar_height
: 0)
5002 + f
->output_data
.x
->top_pos
);
5003 /* The left_pos and top_pos
5004 are now relative to the top and left screen edges,
5005 so the flags should correspond. */
5006 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5009 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5010 to really change the position, and 0 when calling from
5011 x_make_frame_visible (in that case, XOFF and YOFF are the current
5012 position values). It is -1 when calling from x_set_frame_parameters,
5013 which means, do adjust for borders but don't change the gravity. */
5015 x_set_offset (f
, xoff
, yoff
, change_gravity
)
5017 register int xoff
, yoff
;
5020 int modified_top
, modified_left
;
5022 if (change_gravity
> 0)
5024 f
->output_data
.x
->top_pos
= yoff
;
5025 f
->output_data
.x
->left_pos
= xoff
;
5026 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5028 f
->output_data
.x
->size_hint_flags
|= XNegative
;
5030 f
->output_data
.x
->size_hint_flags
|= YNegative
;
5031 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
5033 x_calc_absolute_position (f
);
5036 x_wm_set_size_hint (f
, (long) 0, 0);
5038 /* It is a mystery why we need to add the border_width here
5039 when the frame is already visible, but experiment says we do. */
5040 modified_left
= f
->output_data
.x
->left_pos
;
5041 modified_top
= f
->output_data
.x
->top_pos
;
5042 if (change_gravity
!= 0)
5044 modified_left
+= f
->output_data
.x
->border_width
;
5045 modified_top
+= f
->output_data
.x
->border_width
;
5048 #ifdef USE_X_TOOLKIT
5049 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
5050 modified_left
, modified_top
);
5051 #else /* not USE_X_TOOLKIT */
5052 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5053 modified_left
, modified_top
);
5054 #endif /* not USE_X_TOOLKIT */
5058 /* Call this to change the size of frame F's x-window.
5059 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5060 for this size change and subsequent size changes.
5061 Otherwise we leave the window gravity unchanged. */
5063 x_set_window_size (f
, change_gravity
, cols
, rows
)
5068 int pixelwidth
, pixelheight
;
5071 #ifdef USE_X_TOOLKIT
5074 /* The x and y position of the widget is clobbered by the
5075 call to XtSetValues within EmacsFrameSetCharSize.
5076 This is a real kludge, but I don't understand Xt so I can't
5077 figure out a correct fix. Can anyone else tell me? -- rms. */
5078 int xpos
= f
->output_data
.x
->widget
->core
.x
;
5079 int ypos
= f
->output_data
.x
->widget
->core
.y
;
5080 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
5081 f
->output_data
.x
->widget
->core
.x
= xpos
;
5082 f
->output_data
.x
->widget
->core
.y
= ypos
;
5086 #else /* not USE_X_TOOLKIT */
5090 check_frame_size (f
, &rows
, &cols
);
5091 f
->output_data
.x
->vertical_scroll_bar_extra
5092 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5094 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
5095 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
5096 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
5097 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
5098 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
5100 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
5101 x_wm_set_size_hint (f
, (long) 0, 0);
5103 XSync (FRAME_X_DISPLAY (f
), False
);
5104 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5105 pixelwidth
, pixelheight
);
5107 /* Now, strictly speaking, we can't be sure that this is accurate,
5108 but the window manager will get around to dealing with the size
5109 change request eventually, and we'll hear how it went when the
5110 ConfigureNotify event gets here.
5112 We could just not bother storing any of this information here,
5113 and let the ConfigureNotify event set everything up, but that
5114 might be kind of confusing to the lisp code, since size changes
5115 wouldn't be reported in the frame parameters until some random
5116 point in the future when the ConfigureNotify event arrives. */
5117 change_frame_size (f
, rows
, cols
, 0, 0);
5118 PIXEL_WIDTH (f
) = pixelwidth
;
5119 PIXEL_HEIGHT (f
) = pixelheight
;
5121 /* If cursor was outside the new size, mark it as off. */
5122 if (f
->phys_cursor_y
>= rows
5123 || f
->phys_cursor_x
>= cols
)
5125 f
->phys_cursor_x
= -1;
5126 f
->phys_cursor_y
= -1;
5129 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5130 receive in the ConfigureNotify event; if we get what we asked
5131 for, then the event won't cause the screen to become garbaged, so
5132 we have to make sure to do it here. */
5133 SET_FRAME_GARBAGED (f
);
5135 XFlush (FRAME_X_DISPLAY (f
));
5137 #endif /* not USE_X_TOOLKIT */
5140 /* Mouse warping. */
5143 x_set_mouse_position (f
, x
, y
)
5149 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
5150 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
5152 if (pix_x
< 0) pix_x
= 0;
5153 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
5155 if (pix_y
< 0) pix_y
= 0;
5156 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
5160 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
5161 0, 0, 0, 0, pix_x
, pix_y
);
5165 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
5168 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
5174 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
5175 0, 0, 0, 0, pix_x
, pix_y
);
5179 /* focus shifting, raising and lowering. */
5181 x_focus_on_frame (f
)
5184 #if 0 /* This proves to be unpleasant. */
5188 /* I don't think that the ICCCM allows programs to do things like this
5189 without the interaction of the window manager. Whatever you end up
5190 doing with this code, do it to x_unfocus_frame too. */
5191 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5192 RevertToPointerRoot
, CurrentTime
);
5200 /* Look at the remarks in x_focus_on_frame. */
5201 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
5202 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
5203 RevertToPointerRoot
, CurrentTime
);
5207 /* Raise frame F. */
5212 if (f
->async_visible
)
5215 #ifdef USE_X_TOOLKIT
5216 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
5217 #else /* not USE_X_TOOLKIT */
5218 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5219 #endif /* not USE_X_TOOLKIT */
5220 XFlush (FRAME_X_DISPLAY (f
));
5225 /* Lower frame F. */
5230 if (f
->async_visible
)
5233 #ifdef USE_X_TOOLKIT
5234 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
5235 #else /* not USE_X_TOOLKIT */
5236 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5237 #endif /* not USE_X_TOOLKIT */
5238 XFlush (FRAME_X_DISPLAY (f
));
5244 XTframe_raise_lower (f
, raise_flag
)
5254 /* Change of visibility. */
5256 /* This tries to wait until the frame is really visible.
5257 However, if the window manager asks the user where to position
5258 the frame, this will return before the user finishes doing that.
5259 The frame will not actually be visible at that time,
5260 but it will become visible later when the window manager
5261 finishes with it. */
5263 x_make_frame_visible (f
)
5271 type
= x_icon_type (f
);
5273 x_bitmap_icon (f
, type
);
5275 if (! FRAME_VISIBLE_P (f
))
5277 /* We test FRAME_GARBAGED_P here to make sure we don't
5278 call x_set_offset a second time
5279 if we get to x_make_frame_visible a second time
5280 before the window gets really visible. */
5281 if (! FRAME_ICONIFIED_P (f
)
5282 && ! f
->output_data
.x
->asked_for_visible
)
5283 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
5285 f
->output_data
.x
->asked_for_visible
= 1;
5287 if (! EQ (Vx_no_window_manager
, Qt
))
5288 x_wm_set_window_state (f
, NormalState
);
5289 #ifdef USE_X_TOOLKIT
5290 /* This was XtPopup, but that did nothing for an iconified frame. */
5291 XtMapWidget (f
->output_data
.x
->widget
);
5292 #else /* not USE_X_TOOLKIT */
5293 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5294 #endif /* not USE_X_TOOLKIT */
5295 #if 0 /* This seems to bring back scroll bars in the wrong places
5296 if the window configuration has changed. They seem
5297 to come back ok without this. */
5298 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5299 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5303 XFlush (FRAME_X_DISPLAY (f
));
5305 /* Synchronize to ensure Emacs knows the frame is visible
5306 before we do anything else. We do this loop with input not blocked
5307 so that incoming events are handled. */
5310 int count
= input_signal_count
;
5312 /* This must come after we set COUNT. */
5315 XSETFRAME (frame
, f
);
5320 /* Once we have handled input events,
5321 we should have received the MapNotify if one is coming.
5322 So if we have not got it yet, stop looping.
5323 Some window managers make their own decisions
5324 about visibility. */
5325 if (input_signal_count
!= count
)
5327 /* Machines that do polling rather than SIGIO have been observed
5328 to go into a busy-wait here. So we'll fake an alarm signal
5329 to let the handler know that there's something to be read.
5330 We used to raise a real alarm, but it seems that the handler
5331 isn't always enabled here. This is probably a bug. */
5332 if (input_polling_used ())
5334 /* It could be confusing if a real alarm arrives while processing
5335 the fake one. Turn it off and let the handler reset it. */
5337 input_poll_signal ();
5339 /* Once we have handled input events,
5340 we should have received the MapNotify if one is coming.
5341 So if we have not got it yet, stop looping.
5342 Some window managers make their own decisions
5343 about visibility. */
5344 if (input_signal_count
!= count
)
5347 FRAME_SAMPLE_VISIBILITY (f
);
5351 /* Change from mapped state to withdrawn state. */
5353 /* Make the frame visible (mapped and not iconified). */
5355 x_make_frame_invisible (f
)
5361 #ifdef USE_X_TOOLKIT
5362 /* Use the frame's outermost window, not the one we normally draw on. */
5363 window
= XtWindow (f
->output_data
.x
->widget
);
5364 #else /* not USE_X_TOOLKIT */
5365 window
= FRAME_X_WINDOW (f
);
5366 #endif /* not USE_X_TOOLKIT */
5368 /* Don't keep the highlight on an invisible frame. */
5369 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5370 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5372 #if 0/* This might add unreliability; I don't trust it -- rms. */
5373 if (! f
->async_visible
&& ! f
->async_iconified
)
5379 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
5380 that the current position of the window is user-specified, rather than
5381 program-specified, so that when the window is mapped again, it will be
5382 placed at the same location, without forcing the user to position it
5383 by hand again (they have already done that once for this window.) */
5384 x_wm_set_size_hint (f
, (long) 0, 1);
5388 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
5389 DefaultScreen (FRAME_X_DISPLAY (f
))))
5391 UNBLOCK_INPUT_RESIGNAL
;
5392 error ("Can't notify window manager of window withdrawal");
5394 #else /* ! defined (HAVE_X11R4) */
5396 /* Tell the window manager what we're going to do. */
5397 if (! EQ (Vx_no_window_manager
, Qt
))
5401 unmap
.xunmap
.type
= UnmapNotify
;
5402 unmap
.xunmap
.window
= window
;
5403 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
5404 unmap
.xunmap
.from_configure
= False
;
5405 if (! XSendEvent (FRAME_X_DISPLAY (f
),
5406 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
5408 SubstructureRedirectMask
|SubstructureNotifyMask
,
5411 UNBLOCK_INPUT_RESIGNAL
;
5412 error ("Can't notify window manager of withdrawal");
5416 /* Unmap the window ourselves. Cheeky! */
5417 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
5418 #endif /* ! defined (HAVE_X11R4) */
5420 /* We can't distinguish this from iconification
5421 just by the event that we get from the server.
5422 So we can't win using the usual strategy of letting
5423 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5424 and synchronize with the server to make sure we agree. */
5426 FRAME_ICONIFIED_P (f
) = 0;
5427 f
->async_visible
= 0;
5428 f
->async_iconified
= 0;
5435 /* Change window state from mapped to iconified. */
5444 /* Don't keep the highlight on an invisible frame. */
5445 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5446 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5448 if (f
->async_iconified
)
5453 FRAME_SAMPLE_VISIBILITY (f
);
5455 type
= x_icon_type (f
);
5457 x_bitmap_icon (f
, type
);
5459 #ifdef USE_X_TOOLKIT
5461 if (! FRAME_VISIBLE_P (f
))
5463 if (! EQ (Vx_no_window_manager
, Qt
))
5464 x_wm_set_window_state (f
, IconicState
);
5465 /* This was XtPopup, but that did nothing for an iconified frame. */
5466 XtMapWidget (f
->output_data
.x
->widget
);
5471 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
5472 XtWindow (f
->output_data
.x
->widget
),
5473 DefaultScreen (FRAME_X_DISPLAY (f
)));
5477 error ("Can't notify window manager of iconification");
5479 f
->async_iconified
= 1;
5482 XFlush (FRAME_X_DISPLAY (f
));
5484 #else /* not USE_X_TOOLKIT */
5486 /* Make sure the X server knows where the window should be positioned,
5487 in case the user deiconifies with the window manager. */
5488 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
5489 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
5491 /* Since we don't know which revision of X we're running, we'll use both
5492 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
5494 /* X11R4: send a ClientMessage to the window manager using the
5495 WM_CHANGE_STATE type. */
5499 message
.xclient
.window
= FRAME_X_WINDOW (f
);
5500 message
.xclient
.type
= ClientMessage
;
5501 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
5502 message
.xclient
.format
= 32;
5503 message
.xclient
.data
.l
[0] = IconicState
;
5505 if (! XSendEvent (FRAME_X_DISPLAY (f
),
5506 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
5508 SubstructureRedirectMask
| SubstructureNotifyMask
,
5511 UNBLOCK_INPUT_RESIGNAL
;
5512 error ("Can't notify window manager of iconification");
5516 /* X11R3: set the initial_state field of the window manager hints to
5518 x_wm_set_window_state (f
, IconicState
);
5520 if (!FRAME_VISIBLE_P (f
))
5522 /* If the frame was withdrawn, before, we must map it. */
5523 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5526 f
->async_iconified
= 1;
5528 XFlush (FRAME_X_DISPLAY (f
));
5530 #endif /* not USE_X_TOOLKIT */
5533 /* Destroy the X window of frame F. */
5535 x_destroy_window (f
)
5538 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5542 if (f
->output_data
.x
->icon_desc
!= 0)
5543 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
5544 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->window_desc
);
5545 #ifdef USE_X_TOOLKIT
5546 XtDestroyWidget (f
->output_data
.x
->widget
);
5547 free_frame_menubar (f
);
5548 #endif /* USE_X_TOOLKIT */
5550 free_frame_faces (f
);
5551 XFlush (FRAME_X_DISPLAY (f
));
5553 xfree (f
->output_data
.x
);
5554 f
->output_data
.x
= 0;
5555 if (f
== dpyinfo
->x_focus_frame
)
5556 dpyinfo
->x_focus_frame
= 0;
5557 if (f
== dpyinfo
->x_focus_event_frame
)
5558 dpyinfo
->x_focus_event_frame
= 0;
5559 if (f
== dpyinfo
->x_highlight_frame
)
5560 dpyinfo
->x_highlight_frame
= 0;
5562 dpyinfo
->reference_count
--;
5564 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5566 dpyinfo
->mouse_face_beg_row
5567 = dpyinfo
->mouse_face_beg_col
= -1;
5568 dpyinfo
->mouse_face_end_row
5569 = dpyinfo
->mouse_face_end_col
= -1;
5570 dpyinfo
->mouse_face_window
= Qnil
;
5576 /* Setting window manager hints. */
5578 /* Set the normal size hints for the window manager, for frame F.
5579 FLAGS is the flags word to use--or 0 meaning preserve the flags
5580 that the window now has.
5581 If USER_POSITION is nonzero, we set the USPosition
5582 flag (this is useful when FLAGS is 0). */
5584 x_wm_set_size_hint (f
, flags
, user_position
)
5589 XSizeHints size_hints
;
5591 #ifdef USE_X_TOOLKIT
5594 Dimension widget_width
, widget_height
;
5595 Window window
= XtWindow (f
->output_data
.x
->widget
);
5596 #else /* not USE_X_TOOLKIT */
5597 Window window
= FRAME_X_WINDOW (f
);
5598 #endif /* not USE_X_TOOLKIT */
5600 /* Setting PMaxSize caused various problems. */
5601 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
5603 flexlines
= f
->height
;
5605 size_hints
.x
= f
->output_data
.x
->left_pos
;
5606 size_hints
.y
= f
->output_data
.x
->top_pos
;
5608 #ifdef USE_X_TOOLKIT
5609 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
5610 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
5611 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
5612 size_hints
.height
= widget_height
;
5613 size_hints
.width
= widget_width
;
5614 #else /* not USE_X_TOOLKIT */
5615 size_hints
.height
= PIXEL_HEIGHT (f
);
5616 size_hints
.width
= PIXEL_WIDTH (f
);
5617 #endif /* not USE_X_TOOLKIT */
5619 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
5620 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
5621 size_hints
.max_width
5622 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
5623 size_hints
.max_height
5624 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
5626 /* Calculate the base and minimum sizes.
5628 (When we use the X toolkit, we don't do it here.
5629 Instead we copy the values that the widgets are using, below.) */
5630 #ifndef USE_X_TOOLKIT
5632 int base_width
, base_height
;
5633 int min_rows
= 0, min_cols
= 0;
5635 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
5636 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
5638 check_frame_size (f
, &min_rows
, &min_cols
);
5640 /* The window manager uses the base width hints to calculate the
5641 current number of rows and columns in the frame while
5642 resizing; min_width and min_height aren't useful for this
5643 purpose, since they might not give the dimensions for a
5644 zero-row, zero-column frame.
5646 We use the base_width and base_height members if we have
5647 them; otherwise, we set the min_width and min_height members
5648 to the size for a zero x zero frame. */
5651 size_hints
.flags
|= PBaseSize
;
5652 size_hints
.base_width
= base_width
;
5653 size_hints
.base_height
= base_height
;
5654 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
5655 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
5657 size_hints
.min_width
= base_width
;
5658 size_hints
.min_height
= base_height
;
5662 /* If we don't need the old flags, we don't need the old hint at all. */
5665 size_hints
.flags
|= flags
;
5668 #endif /* not USE_X_TOOLKIT */
5671 XSizeHints hints
; /* Sometimes I hate X Windows... */
5672 long supplied_return
;
5676 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
5679 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
5682 #ifdef USE_X_TOOLKIT
5683 size_hints
.base_height
= hints
.base_height
;
5684 size_hints
.base_width
= hints
.base_width
;
5685 size_hints
.min_height
= hints
.min_height
;
5686 size_hints
.min_width
= hints
.min_width
;
5690 size_hints
.flags
|= flags
;
5695 if (hints
.flags
& PSize
)
5696 size_hints
.flags
|= PSize
;
5697 if (hints
.flags
& PPosition
)
5698 size_hints
.flags
|= PPosition
;
5699 if (hints
.flags
& USPosition
)
5700 size_hints
.flags
|= USPosition
;
5701 if (hints
.flags
& USSize
)
5702 size_hints
.flags
|= USSize
;
5709 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
5710 size_hints
.flags
|= PWinGravity
;
5714 size_hints
.flags
&= ~ PPosition
;
5715 size_hints
.flags
|= USPosition
;
5717 #endif /* PWinGravity */
5720 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
5722 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
5726 /* Used for IconicState or NormalState */
5727 x_wm_set_window_state (f
, state
)
5731 #ifdef USE_X_TOOLKIT
5734 XtSetArg (al
[0], XtNinitialState
, state
);
5735 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
5736 #else /* not USE_X_TOOLKIT */
5737 Window window
= FRAME_X_WINDOW (f
);
5739 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
5740 f
->output_data
.x
->wm_hints
.initial_state
= state
;
5742 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5743 #endif /* not USE_X_TOOLKIT */
5746 x_wm_set_icon_pixmap (f
, pixmap_id
)
5750 #ifdef USE_X_TOOLKIT
5751 Window window
= XtWindow (f
->output_data
.x
->widget
);
5753 Window window
= FRAME_X_WINDOW (f
);
5758 Pixmap icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
5759 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
5763 /* It seems there is no way to turn off use of an icon pixmap.
5764 The following line does it, only if no icon has yet been created,
5765 for some window managers. But with mwm it crashes.
5766 Some people say it should clear the IconPixmapHint bit in this case,
5767 but that doesn't work, and the X consortium said it isn't the
5768 right thing at all. Since there is no way to win,
5769 best to explicitly give up. */
5771 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
5777 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
5778 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5781 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5785 #ifdef USE_X_TOOLKIT
5786 Window window
= XtWindow (f
->output_data
.x
->widget
);
5788 Window window
= FRAME_X_WINDOW (f
);
5791 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
5792 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
5793 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
5795 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5799 /* Initialization. */
5801 #ifdef USE_X_TOOLKIT
5802 static XrmOptionDescRec emacs_options
[] = {
5803 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
5804 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
5806 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
5807 XrmoptionSepArg
, NULL
},
5808 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
5810 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5811 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5812 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5813 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5814 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5815 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
5816 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
5818 #endif /* USE_X_TOOLKIT */
5820 static int x_initialized
;
5823 /* Test whether two display-name strings agree up to the dot that separates
5824 the screen number from the server number. */
5826 same_x_server (name1
, name2
)
5827 char *name1
, *name2
;
5830 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
5834 if (seen_colon
&& *name1
== '.')
5838 && (*name1
== '.' || *name1
== '\0')
5839 && (*name2
== '.' || *name2
== '\0'));
5843 struct x_display_info
*
5844 x_term_init (display_name
, xrm_option
, resource_name
)
5845 Lisp_Object display_name
;
5847 char *resource_name
;
5853 struct x_display_info
*dpyinfo
;
5865 setlocale (LC_ALL
, NULL
);
5868 #ifdef USE_X_TOOLKIT
5869 /* weiner@footloose.sps.mot.com reports that this causes
5871 X protocol error: BadAtom (invalid Atom parameter)
5872 on protocol request 18skiloaf.
5873 So let's not use it until R6. */
5875 XtSetLanguageProc (NULL
, NULL
, NULL
);
5886 argv
[argc
++] = "-xrm";
5887 argv
[argc
++] = xrm_option
;
5889 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
5890 resource_name
, EMACS_CLASS
,
5891 emacs_options
, XtNumber (emacs_options
),
5895 setlocale (LC_NUMERIC
, "C");
5896 setlocale (LC_TIME
, "C");
5900 #else /* not USE_X_TOOLKIT */
5902 XSetLocaleModifiers ("");
5904 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
5905 #endif /* not USE_X_TOOLKIT */
5907 /* Detect failure. */
5914 /* We have definitely succeeded. Record the new connection. */
5916 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
5920 struct x_display_info
*share
;
5923 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
5924 share
= share
->next
, tail
= XCONS (tail
)->cdr
)
5925 if (same_x_server (XSTRING (XCONS (XCONS (tail
)->car
)->car
)->data
,
5926 XSTRING (display_name
)->data
))
5929 dpyinfo
->kboard
= share
->kboard
;
5932 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
5933 init_kboard (dpyinfo
->kboard
);
5934 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
5936 char *vendor
= ServerVendor (dpy
);
5937 dpyinfo
->kboard
->Vsystem_key_alist
5938 = call1 (Qvendor_specific_keysyms
,
5939 build_string (vendor
? vendor
: ""));
5942 dpyinfo
->kboard
->next_kboard
= all_kboards
;
5943 all_kboards
= dpyinfo
->kboard
;
5944 /* Don't let the initial kboard remain current longer than necessary.
5945 That would cause problems if a file loaded on startup tries to
5946 prompt in the minibuffer. */
5947 if (current_kboard
== initial_kboard
)
5948 current_kboard
= dpyinfo
->kboard
;
5950 dpyinfo
->kboard
->reference_count
++;
5954 /* Put this display on the chain. */
5955 dpyinfo
->next
= x_display_list
;
5956 x_display_list
= dpyinfo
;
5958 /* Put it on x_display_name_list as well, to keep them parallel. */
5959 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
5960 x_display_name_list
);
5961 dpyinfo
->name_list_element
= XCONS (x_display_name_list
)->car
;
5963 dpyinfo
->display
= dpy
;
5966 XSetAfterFunction (x_current_display
, x_trace_wire
);
5970 = (char *) xmalloc (XSTRING (Vinvocation_name
)->size
5971 + XSTRING (Vsystem_name
)->size
5973 sprintf (dpyinfo
->x_id_name
, "%s@%s",
5974 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
5976 /* Figure out which modifier bits mean what. */
5977 x_find_modifier_meanings (dpyinfo
);
5979 /* Get the scroll bar cursor. */
5980 dpyinfo
->vertical_scroll_bar_cursor
5981 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
5983 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
5984 resource_name
, EMACS_CLASS
);
5985 #ifdef HAVE_XRMSETDATABASE
5986 XrmSetDatabase (dpyinfo
->display
, xrdb
);
5988 dpyinfo
->display
->db
= xrdb
;
5990 /* Put the rdb where we can find it in a way that works on
5992 dpyinfo
->xrdb
= xrdb
;
5994 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
5995 DefaultScreen (dpyinfo
->display
));
5996 dpyinfo
->visual
= select_visual (dpyinfo
->display
, dpyinfo
->screen
,
5997 &dpyinfo
->n_planes
);
5998 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
5999 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
6000 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
6001 dpyinfo
->grabbed
= 0;
6002 dpyinfo
->reference_count
= 0;
6003 dpyinfo
->icon_bitmap_id
= -1;
6004 dpyinfo
->n_fonts
= 0;
6005 dpyinfo
->font_table_size
= 0;
6006 dpyinfo
->bitmaps
= 0;
6007 dpyinfo
->bitmaps_size
= 0;
6008 dpyinfo
->bitmaps_last
= 0;
6009 dpyinfo
->scratch_cursor_gc
= 0;
6010 dpyinfo
->mouse_face_mouse_frame
= 0;
6011 dpyinfo
->mouse_face_deferred_gc
= 0;
6012 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6013 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6014 dpyinfo
->mouse_face_face_id
= 0;
6015 dpyinfo
->mouse_face_window
= Qnil
;
6016 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
6017 dpyinfo
->mouse_face_defer
= 0;
6018 dpyinfo
->x_focus_frame
= 0;
6019 dpyinfo
->x_focus_event_frame
= 0;
6020 dpyinfo
->x_highlight_frame
= 0;
6022 dpyinfo
->Xatom_wm_protocols
6023 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
6024 dpyinfo
->Xatom_wm_take_focus
6025 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
6026 dpyinfo
->Xatom_wm_save_yourself
6027 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
6028 dpyinfo
->Xatom_wm_delete_window
6029 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
6030 dpyinfo
->Xatom_wm_change_state
6031 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
6032 dpyinfo
->Xatom_wm_configure_denied
6033 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
6034 dpyinfo
->Xatom_wm_window_moved
6035 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
6036 dpyinfo
->Xatom_editres
6037 = XInternAtom (dpyinfo
->display
, "Editres", False
);
6038 dpyinfo
->Xatom_CLIPBOARD
6039 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
6040 dpyinfo
->Xatom_TIMESTAMP
6041 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
6043 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
6044 dpyinfo
->Xatom_DELETE
6045 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
6046 dpyinfo
->Xatom_MULTIPLE
6047 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
6049 = XInternAtom (dpyinfo
->display
, "INCR", False
);
6050 dpyinfo
->Xatom_EMACS_TMP
6051 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
6052 dpyinfo
->Xatom_TARGETS
6053 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
6055 = XInternAtom (dpyinfo
->display
, "NULL", False
);
6056 dpyinfo
->Xatom_ATOM_PAIR
6057 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
6059 dpyinfo
->cut_buffers_initialized
= 0;
6061 connection
= ConnectionNumber (dpyinfo
->display
);
6062 dpyinfo
->connection
= connection
;
6065 /* This is only needed for distinguishing keyboard and process input. */
6066 if (connection
!= 0)
6067 add_keyboard_wait_descriptor (connection
);
6070 #ifndef F_SETOWN_BUG
6072 #ifdef F_SETOWN_SOCK_NEG
6073 /* stdin is a socket here */
6074 fcntl (connection
, F_SETOWN
, -getpid ());
6075 #else /* ! defined (F_SETOWN_SOCK_NEG) */
6076 fcntl (connection
, F_SETOWN
, getpid ());
6077 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
6078 #endif /* ! defined (F_SETOWN) */
6079 #endif /* F_SETOWN_BUG */
6082 if (interrupt_input
)
6083 init_sigio (connection
);
6084 #endif /* ! defined (SIGIO) */
6091 /* Get rid of display DPYINFO, assuming all frames are already gone,
6092 and without sending any more commands to the X server. */
6095 x_delete_display (dpyinfo
)
6096 struct x_display_info
*dpyinfo
;
6098 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
6100 /* Discard this display from x_display_name_list and x_display_list.
6101 We can't use Fdelq because that can quit. */
6102 if (! NILP (x_display_name_list
)
6103 && EQ (XCONS (x_display_name_list
)->car
, dpyinfo
->name_list_element
))
6104 x_display_name_list
= XCONS (x_display_name_list
)->cdr
;
6109 tail
= x_display_name_list
;
6110 while (CONSP (tail
) && CONSP (XCONS (tail
)->cdr
))
6112 if (EQ (XCONS (XCONS (tail
)->cdr
)->car
,
6113 dpyinfo
->name_list_element
))
6115 XCONS (tail
)->cdr
= XCONS (XCONS (tail
)->cdr
)->cdr
;
6118 tail
= XCONS (tail
)->cdr
;
6122 if (x_display_list
== dpyinfo
)
6123 x_display_list
= dpyinfo
->next
;
6126 struct x_display_info
*tail
;
6128 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
6129 if (tail
->next
== dpyinfo
)
6130 tail
->next
= tail
->next
->next
;
6133 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
6134 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
6135 XrmDestroyDatabase (dpyinfo
->xrdb
);
6139 if (--dpyinfo
->kboard
->reference_count
== 0)
6140 delete_kboard (dpyinfo
->kboard
);
6142 xfree (dpyinfo
->font_table
);
6143 xfree (dpyinfo
->x_id_name
);
6147 /* Set up use of X before we make the first connection. */
6151 clear_frame_hook
= XTclear_frame
;
6152 clear_end_of_line_hook
= XTclear_end_of_line
;
6153 ins_del_lines_hook
= XTins_del_lines
;
6154 change_line_highlight_hook
= XTchange_line_highlight
;
6155 insert_glyphs_hook
= XTinsert_glyphs
;
6156 write_glyphs_hook
= XTwrite_glyphs
;
6157 delete_glyphs_hook
= XTdelete_glyphs
;
6158 ring_bell_hook
= XTring_bell
;
6159 reset_terminal_modes_hook
= XTreset_terminal_modes
;
6160 set_terminal_modes_hook
= XTset_terminal_modes
;
6161 update_begin_hook
= XTupdate_begin
;
6162 update_end_hook
= XTupdate_end
;
6163 set_terminal_window_hook
= XTset_terminal_window
;
6164 read_socket_hook
= XTread_socket
;
6165 frame_up_to_date_hook
= XTframe_up_to_date
;
6166 cursor_to_hook
= XTcursor_to
;
6167 reassert_line_highlight_hook
= XTreassert_line_highlight
;
6168 mouse_position_hook
= XTmouse_position
;
6169 frame_rehighlight_hook
= XTframe_rehighlight
;
6170 frame_raise_lower_hook
= XTframe_raise_lower
;
6171 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
6172 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
6173 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
6174 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
6176 scroll_region_ok
= 1; /* we'll scroll partial frames */
6177 char_ins_del_ok
= 0; /* just as fast to write the line */
6178 line_ins_del_ok
= 1; /* we'll just blt 'em */
6179 fast_clear_end_of_line
= 1; /* X does this well */
6180 memory_below_frame
= 0; /* we don't remember what scrolls
6186 /* Try to use interrupt input; if we can't, then start polling. */
6187 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
6189 #ifdef USE_X_TOOLKIT
6190 XtToolkitInitialize ();
6191 Xt_app_con
= XtCreateApplicationContext ();
6192 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
6195 /* Note that there is no real way portable across R3/R4 to get the
6196 original error handler. */
6197 XSetErrorHandler (x_error_quitter
);
6198 XSetIOErrorHandler (x_io_error_quitter
);
6200 /* Disable Window Change signals; they are handled by X events. */
6202 signal (SIGWINCH
, SIG_DFL
);
6203 #endif /* ! defined (SIGWINCH) */
6205 signal (SIGPIPE
, x_connection_signal
);
6211 staticpro (&x_display_name_list
);
6212 x_display_name_list
= Qnil
;
6214 staticpro (&last_mouse_scroll_bar
);
6215 last_mouse_scroll_bar
= Qnil
;
6217 staticpro (&Qvendor_specific_keysyms
);
6218 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
6220 #endif /* ! defined (HAVE_X_WINDOWS) */