1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 93, 94, 95, 1996 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_SYSTEM) */
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 #include <X11/Shell.h>
92 extern void free_frame_menubar ();
93 extern FRAME_PTR
x_menubar_window_to_frame ();
94 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
96 extern void _XEditResCheckMessages ();
97 #endif /* not NO_EDITRES */
98 #endif /* USE_X_TOOLKIT */
100 #ifndef USE_X_TOOLKIT
101 #define x_any_window_to_frame x_window_to_frame
102 #define x_top_window_to_frame x_window_to_frame
107 #ifndef XtNinitialState
108 #define XtNinitialState "initialState"
112 #ifdef HAVE_SETLOCALE
113 /* So we can do setlocale. */
118 /* memmove will be defined as a macro in Xfuncs.h unless
119 <string.h> is included beforehand. The declaration for memmove in
120 <string.h> will cause a syntax error when Xfuncs.h later includes it. */
125 #define min(a,b) ((a)<(b) ? (a) : (b))
128 #define max(a,b) ((a)>(b) ? (a) : (b))
131 /* This is a chain of structures for all the X displays currently in use. */
132 struct x_display_info
*x_display_list
;
134 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
135 one for each element of x_display_list and in the same order.
136 NAME is the name of the frame.
137 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
138 Lisp_Object x_display_name_list
;
140 /* Frame being updated by update_frame. This is declared in term.c.
141 This is set by update_begin and looked at by all the
142 XT functions. It is zero while not inside an update.
143 In that case, the XT functions assume that `selected_frame'
144 is the frame to apply to. */
145 extern struct frame
*updating_frame
;
147 extern waiting_for_input
;
149 /* This is a frame waiting to be autoraised, within XTread_socket. */
150 struct frame
*pending_autoraise_frame
;
153 /* The application context for Xt use. */
154 XtAppContext Xt_app_con
;
156 static String Xt_default_resources
[] =
162 /* During an update, maximum vpos for ins/del line operations to affect. */
164 static int flexlines
;
166 /* During an update, nonzero if chars output now should be highlighted. */
168 static int highlight
;
170 /* Nominal cursor position -- where to draw output.
171 During an update, these are different from the cursor-box position. */
178 Formerly, we used PointerMotionHintMask (in STANDARD_EVENT_MASK)
179 so that we would have to call XQueryPointer after each MotionNotify
180 event to ask for another such event. However, this made mouse tracking
181 slow, and there was a bug that made it eventually stop.
183 Simply asking for MotionNotify all the time seems to work better.
185 In order to avoid asking for motion events and then throwing most
186 of them away or busy-polling the server for mouse positions, we ask
187 the server for pointer motion hints. This means that we get only
188 one event per group of mouse movements. "Groups" are delimited by
189 other kinds of events (focus changes and button clicks, for
190 example), or by XQueryPointer calls; when one of these happens, we
191 get another MotionNotify event the next time the mouse moves. This
192 is at least as efficient as getting motion events when mouse
193 tracking is on, and I suspect only negligibly worse when tracking
196 /* Where the mouse was last time we reported a mouse event. */
197 static FRAME_PTR last_mouse_frame
;
198 static XRectangle last_mouse_glyph
;
200 static Lisp_Object last_mouse_press_frame
;
202 /* The scroll bar in which the last X motion event occurred.
204 If the last X motion event occurred in a scroll bar, we set this
205 so XTmouse_position can know whether to report a scroll bar motion or
208 If the last X motion event didn't occur in a scroll bar, we set this
209 to Qnil, to tell XTmouse_position to return an ordinary motion event. */
210 static Lisp_Object last_mouse_scroll_bar
;
212 /* This is a hack. We would really prefer that XTmouse_position would
213 return the time associated with the position it returns, but there
214 doesn't seem to be any way to wrest the timestamp from the server
215 along with the position query. So, we just keep track of the time
216 of the last movement we received, and return that in hopes that
217 it's somewhat accurate. */
218 static Time last_mouse_movement_time
;
220 /* Incremented by XTread_socket whenever it really tries to read events. */
222 static int volatile input_signal_count
;
224 static int input_signal_count
;
227 /* Used locally within XTread_socket. */
228 static int x_noop_count
;
230 /* Initial values of argv and argc. */
231 extern char **initial_argv
;
232 extern int initial_argc
;
234 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
236 /* Tells if a window manager is present or not. */
238 extern Lisp_Object Vx_no_window_manager
;
240 extern Lisp_Object Qface
, Qmouse_face
;
244 /* A mask of extra modifier bits to put into every keyboard char. */
245 extern int extra_keyboard_modifiers
;
247 static Lisp_Object Qvendor_specific_keysyms
;
249 extern XrmDatabase
x_load_resources ();
251 extern Lisp_Object
x_icon_type ();
253 void x_delete_display ();
255 static void redraw_previous_char ();
256 static void redraw_following_char ();
257 static unsigned int x_x_to_emacs_modifiers ();
259 static int fast_find_position ();
260 static void note_mouse_highlight ();
261 static void clear_mouse_face ();
262 static void show_mouse_face ();
263 static void do_line_dance ();
265 static int XTcursor_to ();
266 static int XTclear_end_of_line ();
267 static int x_io_error_quitter ();
268 void x_catch_errors ();
269 void x_uncatch_errors ();
272 /* This is a function useful for recording debugging information
273 about the sequence of occurrences in this file. */
281 struct record event_record
[100];
283 int event_record_index
;
285 record_event (locus
, type
)
289 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
290 event_record_index
= 0;
292 event_record
[event_record_index
].locus
= locus
;
293 event_record
[event_record_index
].type
= type
;
294 event_record_index
++;
299 /* Return the struct x_display_info corresponding to DPY. */
301 struct x_display_info
*
302 x_display_info_for_display (dpy
)
305 struct x_display_info
*dpyinfo
;
307 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
308 if (dpyinfo
->display
== dpy
)
314 /* Starting and ending updates.
316 These hooks are called by update_frame at the beginning and end
317 of a frame update. We record in `updating_frame' the identity
318 of the frame being updated, so that the XT... functions do not
319 need to take a frame as argument. Most of the XT... functions
320 should never be called except during an update, the only exceptions
321 being XTcursor_to, XTwrite_glyphs and XTreassert_line_highlight. */
332 flexlines
= f
->height
;
337 curs_x
= FRAME_CURSOR_X (f
);
338 curs_y
= FRAME_CURSOR_Y (f
);
340 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
342 /* Don't do highlighting for mouse motion during the update. */
343 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 1;
345 /* If the frame needs to be redrawn,
346 simply forget about any prior mouse highlighting. */
347 if (FRAME_GARBAGED_P (f
))
348 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= Qnil
;
350 if (!NILP (FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
))
352 int firstline
, lastline
, i
;
353 struct window
*w
= XWINDOW (FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
);
355 /* Find the first, and the last+1, lines affected by redisplay. */
356 for (firstline
= 0; firstline
< f
->height
; firstline
++)
357 if (FRAME_DESIRED_GLYPHS (f
)->enable
[firstline
])
360 lastline
= f
->height
;
361 for (i
= f
->height
- 1; i
>= 0; i
--)
363 if (FRAME_DESIRED_GLYPHS (f
)->enable
[i
])
369 /* Can we tell that this update does not affect the window
370 where the mouse highlight is? If so, no need to turn off.
371 Likewise, don't do anything if the frame is garbaged;
372 in that case, the FRAME_CURRENT_GLYPHS that we would use
373 are all wrong, and we will redisplay that line anyway. */
374 if (! (firstline
> (XFASTINT (w
->top
) + window_internal_height (w
))
375 || lastline
< XFASTINT (w
->top
)))
376 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
392 x_display_cursor (f
, 1, curs_x
, curs_y
);
394 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
396 /* This fails in the case of having updated only the echo area
397 if we have switched buffers. In that case, FRAME_CURRENT_GLYPHS
398 has no relation to the current contents, and its charstarts
399 have no relation to the contents of the window-buffer.
400 I don't know a clean way to check
401 for that case. window_end_valid isn't set up yet. */
402 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
403 note_mouse_highlight (f
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
404 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
407 XFlush (FRAME_X_DISPLAY (f
));
411 /* This is called after a redisplay on frame F. */
414 XTframe_up_to_date (f
)
418 if (FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
419 || f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
421 note_mouse_highlight (FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
,
422 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
423 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
424 FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 0;
429 /* External interface to control of standout mode.
430 Call this when about to modify line at position VPOS
431 and not change whether it is highlighted. */
433 XTreassert_line_highlight (new, vpos
)
439 /* Call this when about to modify line at position VPOS
440 and change whether it is highlighted. */
443 XTchange_line_highlight (new_highlight
, vpos
, first_unused_hpos
)
444 int new_highlight
, vpos
, first_unused_hpos
;
446 highlight
= new_highlight
;
447 XTcursor_to (vpos
, 0);
448 XTclear_end_of_line (updating_frame
->width
);
451 /* This is used when starting Emacs and when restarting after suspend.
452 When starting Emacs, no X window is mapped. And nothing must be done
453 to Emacs's own window if it is suspended (though that rarely happens). */
456 XTset_terminal_modes ()
460 /* This is called when exiting or suspending Emacs.
461 Exiting will make the X-windows go away, and suspending
462 requires no action. */
465 XTreset_terminal_modes ()
467 /* XTclear_frame (); */
470 /* Set the nominal cursor position of the frame.
471 This is where display update commands will take effect.
472 This does not affect the place where the cursor-box is displayed. */
475 XTcursor_to (row
, col
)
476 register int row
, col
;
484 if (updating_frame
== 0)
487 x_display_cursor (selected_frame
, 1, curs_x
, curs_y
);
488 XFlush (FRAME_X_DISPLAY (selected_frame
));
493 /* Display a sequence of N glyphs found at GP.
494 WINDOW is the x-window to output to. LEFT and TOP are starting coords.
495 HL is 1 if this text is highlighted, 2 if the cursor is on it,
496 3 if should appear in its mouse-face.
497 JUST_FOREGROUND if 1 means draw only the foreground;
498 don't alter the background.
500 FONT is the default font to use (for glyphs whose font-code is 0).
502 Since the display generation code is responsible for calling
503 compute_char_face and compute_glyph_face on everything it puts in
504 the display structure, we can assume that the face code on each
505 glyph is a valid index into FRAME_COMPUTED_FACES (f), and the one
506 to which we can actually apply intern_face.
507 Call this function with input blocked. */
510 /* This is the multi-face code. */
513 dumpglyphs (f
, left
, top
, gp
, n
, hl
, just_foreground
)
516 register GLYPH
*gp
; /* Points to first GLYPH. */
517 register int n
; /* Number of glyphs to display. */
521 /* Holds characters to be displayed. */
522 char *buf
= (char *) alloca (f
->width
* sizeof (*buf
));
523 register char *cp
; /* Steps through buf[]. */
524 register int tlen
= GLYPH_TABLE_LENGTH
;
525 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
526 Window window
= FRAME_X_WINDOW (f
);
527 int orig_left
= left
;
531 /* Get the face-code of the next GLYPH. */
535 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
536 cf
= FAST_GLYPH_FACE (g
);
538 /* Find the run of consecutive glyphs with the same face-code.
539 Extract their character codes into BUF. */
544 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
545 if (FAST_GLYPH_FACE (g
) != cf
)
548 *cp
++ = FAST_GLYPH_CHAR (g
);
553 /* LEN gets the length of the run. */
556 /* Now output this run of chars, with the font and pixel values
557 determined by the face code CF. */
559 struct face
*face
= FRAME_DEFAULT_FACE (f
);
560 XFontStruct
*font
= FACE_FONT (face
);
561 GC gc
= FACE_GC (face
);
564 /* HL = 3 means use a mouse face previously chosen. */
566 cf
= FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
;
568 /* First look at the face of the text itself. */
571 /* It's possible for the display table to specify
572 a face code that is out of range. Use 0 in that case. */
573 if (cf
< 0 || cf
>= FRAME_N_COMPUTED_FACES (f
)
574 || FRAME_COMPUTED_FACES (f
) [cf
] == 0)
578 face
= FRAME_MODE_LINE_FACE (f
);
580 face
= intern_face (f
, FRAME_COMPUTED_FACES (f
) [cf
]);
581 font
= FACE_FONT (face
);
583 if (FACE_STIPPLE (face
))
587 /* Then comes the distinction between modeline and normal text. */
592 face
= FRAME_MODE_LINE_FACE (f
);
593 font
= FACE_FONT (face
);
595 if (FACE_STIPPLE (face
))
599 #define FACE_DEFAULT (~0)
601 /* Now override that if the cursor's on this character. */
604 /* The cursor overrides stippling. */
608 || face
->font
== (XFontStruct
*) FACE_DEFAULT
609 || face
->font
== f
->output_data
.x
->font
)
610 && face
->background
== f
->output_data
.x
->background_pixel
611 && face
->foreground
== f
->output_data
.x
->foreground_pixel
)
613 gc
= f
->output_data
.x
->cursor_gc
;
615 /* Cursor on non-default face: must merge. */
621 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
622 xgcv
.foreground
= face
->background
;
623 /* If the glyph would be invisible,
624 try a different foreground. */
625 if (xgcv
.foreground
== xgcv
.background
)
626 xgcv
.foreground
= face
->foreground
;
627 if (xgcv
.foreground
== xgcv
.background
)
628 xgcv
.foreground
= f
->output_data
.x
->cursor_foreground_pixel
;
629 if (xgcv
.foreground
== xgcv
.background
)
630 xgcv
.foreground
= face
->foreground
;
631 /* Make sure the cursor is distinct from text in this face. */
632 if (xgcv
.background
== face
->background
633 && xgcv
.foreground
== face
->foreground
)
635 xgcv
.background
= face
->foreground
;
636 xgcv
.foreground
= face
->background
;
638 xgcv
.font
= face
->font
->fid
;
639 xgcv
.graphics_exposures
= 0;
640 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
641 if (FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
)
642 XChangeGC (FRAME_X_DISPLAY (f
),
643 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
,
646 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
647 = XCreateGC (FRAME_X_DISPLAY (f
), window
, mask
, &xgcv
);
648 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
650 /* If this code is restored, it must also reset to the default stipple
652 if (face
->stipple
&& face
->stipple
!= FACE_DEFAULT
)
653 XSetStipple (FRAME_X_DISPLAY (f
), gc
, face
->stipple
);
658 if (font
== (XFontStruct
*) FACE_DEFAULT
)
659 font
= f
->output_data
.x
->font
;
662 XDrawString (FRAME_X_DISPLAY (f
), window
, gc
,
663 left
, top
+ FONT_BASE (font
), buf
, len
);
668 /* Turn stipple on. */
669 XSetFillStyle (FRAME_X_DISPLAY (f
), gc
, FillOpaqueStippled
);
671 /* Draw stipple on background. */
672 XFillRectangle (FRAME_X_DISPLAY (f
), window
, gc
,
674 FONT_WIDTH (font
) * len
,
677 /* Turn stipple off. */
678 XSetFillStyle (FRAME_X_DISPLAY (f
), gc
, FillSolid
);
680 /* Draw the text, solidly, onto the stipple pattern. */
681 XDrawString (FRAME_X_DISPLAY (f
), window
, gc
,
682 left
, top
+ FONT_BASE (font
), buf
, len
);
685 XDrawImageString (FRAME_X_DISPLAY (f
), window
, gc
,
686 left
, top
+ FONT_BASE (font
), buf
, len
);
688 /* Clear the rest of the line's height. */
689 if (f
->output_data
.x
->line_height
!= FONT_HEIGHT (font
))
690 XClearArea (FRAME_X_DISPLAY (f
), window
, left
,
691 top
+ FONT_HEIGHT (font
),
692 FONT_WIDTH (font
) * len
,
693 /* This is how many pixels of height
695 f
->output_data
.x
->line_height
- FONT_HEIGHT (font
),
699 #if 0 /* Doesn't work, because it uses FRAME_CURRENT_GLYPHS,
700 which often is not up to date yet. */
701 if (!just_foreground
)
703 if (left
== orig_left
)
704 redraw_previous_char (f
, PIXEL_TO_CHAR_COL (f
, left
),
705 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
707 redraw_following_char (f
, PIXEL_TO_CHAR_COL (f
, left
+ len
* FONT_WIDTH (font
)),
708 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
712 /* We should probably check for XA_UNDERLINE_POSITION and
713 XA_UNDERLINE_THICKNESS properties on the font, but let's
714 just get the thing working, and come back to that. */
716 int underline_position
= 1;
718 if (font
->descent
<= underline_position
)
719 underline_position
= font
->descent
- 1;
722 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
726 + underline_position
),
727 len
* FONT_WIDTH (font
), 1);
730 left
+= len
* FONT_WIDTH (font
);
737 /* This is the old single-face code. */
740 dumpglyphs (f
, left
, top
, gp
, n
, hl
, font
)
743 register GLYPH
*gp
; /* Points to first GLYPH. */
744 register int n
; /* Number of glyphs to display. */
749 Window window
= FRAME_X_WINDOW (f
);
750 GC drawing_gc
= (hl
== 2 ? f
->output_data
.x
->cursor_gc
751 : (hl
? f
->output_data
.x
->reverse_gc
752 : f
->output_data
.x
->normal_gc
));
754 if (sizeof (GLYPH
) == sizeof (XChar2b
))
755 XDrawImageString16 (FRAME_X_DISPLAY (f
), window
, drawing_gc
,
756 left
, top
+ FONT_BASE (font
), (XChar2b
*) gp
, n
);
757 else if (sizeof (GLYPH
) == sizeof (unsigned char))
758 XDrawImageString (FRAME_X_DISPLAY (f
), window
, drawing_gc
,
759 left
, top
+ FONT_BASE (font
), (char *) gp
, n
);
761 /* What size of glyph ARE you using? And does X have a function to
767 /* Output some text at the nominal frame cursor position.
768 Advance the cursor over the text.
769 Output LEN glyphs at START.
771 `highlight', set up by XTreassert_line_highlight or XTchange_line_highlight,
772 controls the pixel values used for foreground and background. */
775 XTwrite_glyphs (start
, len
)
776 register GLYPH
*start
;
779 register int temp_length
;
790 /* If not within an update,
791 output at the frame's visible cursor. */
792 curs_x
= f
->cursor_x
;
793 curs_y
= f
->cursor_y
;
797 CHAR_TO_PIXEL_COL (f
, curs_x
),
798 CHAR_TO_PIXEL_ROW (f
, curs_y
),
799 start
, len
, highlight
, 0);
801 /* If we drew on top of the cursor, note that it is turned off. */
802 if (curs_y
== f
->phys_cursor_y
803 && curs_x
<= f
->phys_cursor_x
804 && curs_x
+ len
> f
->phys_cursor_x
)
805 f
->phys_cursor_x
= -1;
807 if (updating_frame
== 0)
808 x_display_cursor (f
, 1, FRAME_CURSOR_X (f
) + len
, FRAME_CURSOR_Y (f
));
815 /* Clear to the end of the line.
816 Erase the current text line from the nominal cursor position (inclusive)
817 to column FIRST_UNUSED (exclusive). The idea is that everything
818 from FIRST_UNUSED onward is already erased. */
821 XTclear_end_of_line (first_unused
)
822 register int first_unused
;
824 struct frame
*f
= updating_frame
;
830 if (curs_y
< 0 || curs_y
>= f
->height
)
832 if (first_unused
<= 0)
835 if (first_unused
>= f
->width
)
836 first_unused
= f
->width
;
842 /* Notice if the cursor will be cleared by this operation. */
843 if (curs_y
== f
->phys_cursor_y
844 && curs_x
<= f
->phys_cursor_x
845 && f
->phys_cursor_x
< first_unused
)
846 f
->phys_cursor_x
= -1;
848 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
849 CHAR_TO_PIXEL_COL (f
, curs_x
),
850 CHAR_TO_PIXEL_ROW (f
, curs_y
),
851 FONT_WIDTH (f
->output_data
.x
->font
) * (first_unused
- curs_x
),
852 f
->output_data
.x
->line_height
, False
);
854 redraw_previous_char (f
, curs_x
, curs_y
, highlight
);
864 struct frame
*f
= updating_frame
;
869 f
->phys_cursor_x
= -1; /* Cursor not visible. */
870 curs_x
= 0; /* Nominal cursor position is top left. */
875 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
877 /* We have to clear the scroll bars, too. If we have changed
878 colors or something like that, then they should be notified. */
879 x_scroll_bar_clear (f
);
881 XFlush (FRAME_X_DISPLAY (f
));
886 /* This currently does not work because FRAME_CURRENT_GLYPHS doesn't
887 always contain the right glyphs to use.
889 It also needs to be changed to look at the details of the font and
890 see whether there is really overlap, and do nothing when there is
891 not. This can use font_char_overlap_left and font_char_overlap_right,
892 but just how to use them is not clear. */
894 /* Erase the character (if any) at the position just before X, Y in frame F,
895 then redraw it and the character before it.
896 This is necessary when we erase starting at X,
897 in case the character after X overlaps into the one before X.
898 Call this function with input blocked. */
901 redraw_previous_char (f
, x
, y
, highlight_flag
)
906 /* Erase the character before the new ones, in case
907 what was here before overlaps it.
908 Reoutput that character, and the previous character
909 (in case the previous character overlaps it). */
915 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
916 CHAR_TO_PIXEL_COL (f
, x
- 1),
917 CHAR_TO_PIXEL_ROW (f
, y
),
918 FONT_WIDTH (f
->output_data
.x
->font
),
919 f
->output_data
.x
->line_height
, False
);
921 dumpglyphs (f
, CHAR_TO_PIXEL_COL (f
, start_x
),
922 CHAR_TO_PIXEL_ROW (f
, y
),
923 &FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][start_x
],
924 x
- start_x
, highlight_flag
, 1);
928 /* Erase the character (if any) at the position X, Y in frame F,
929 then redraw it and the character after it.
930 This is necessary when we erase endng at X,
931 in case the character after X overlaps into the one before X.
932 Call this function with input blocked. */
935 redraw_following_char (f
, x
, y
, highlight_flag
)
940 int limit
= FRAME_CURRENT_GLYPHS (f
)->used
[y
];
941 /* Erase the character after the new ones, in case
942 what was here before overlaps it.
943 Reoutput that character, and the following character
944 (in case the following character overlaps it). */
946 && FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][x
] != SPACEGLYPH
)
951 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
952 CHAR_TO_PIXEL_COL (f
, x
),
953 CHAR_TO_PIXEL_ROW (f
, y
),
954 FONT_WIDTH (f
->output_data
.x
->font
),
955 f
->output_data
.x
->line_height
, False
);
957 dumpglyphs (f
, CHAR_TO_PIXEL_COL (f
, x
),
958 CHAR_TO_PIXEL_ROW (f
, y
),
959 &FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][x
],
960 end_x
- x
, highlight_flag
, 1);
965 #if 0 /* Not in use yet */
967 /* Return 1 if character C in font F extends past its left edge. */
970 font_char_overlap_left (font
, c
)
976 /* Find the bounding-box info for C. */
977 if (font
->per_char
== 0)
978 s
= &font
->max_bounds
;
981 int rowlen
= font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1;
984 /* Decode char into row number (byte 1) and code within row (byte 2). */
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
))
992 /* If char is out of range, try the font's default char instead. */
993 c
= font
->default_char
;
994 row
= c
>> (BITS_PER_INT
- 8);
997 if (!(within
>= font
->min_char_or_byte2
998 && within
<= font
->max_char_or_byte2
999 && row
>= font
->min_byte1
1000 && row
<= font
->max_byte1
))
1001 /* Still out of range means this char does not overlap. */
1004 /* We found the info for this char. */
1005 s
= (font
->per_char
+ (within
- font
->min_char_or_byte2
)
1009 return (s
&& s
->lbearing
< 0);
1012 /* Return 1 if character C in font F extends past its right edge. */
1015 font_char_overlap_right (font
, c
)
1021 /* Find the bounding-box info for C. */
1022 if (font
->per_char
== 0)
1023 s
= &font
->max_bounds
;
1026 int rowlen
= font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1;
1029 /* Decode char into row number (byte 1) and code within row (byte 2). */
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
))
1037 /* If char is out of range, try the font's default char instead. */
1038 c
= font
->default_char
;
1039 row
= c
>> (BITS_PER_INT
- 8);
1042 if (!(within
>= font
->min_char_or_byte2
1043 && within
<= font
->max_char_or_byte2
1044 && row
>= font
->min_byte1
1045 && row
<= font
->max_byte1
))
1046 /* Still out of range means this char does not overlap. */
1049 /* We found the info for this char. */
1050 s
= (font
->per_char
+ (within
- font
->min_char_or_byte2
)
1054 return (s
&& s
->rbearing
>= s
->width
);
1058 /* Invert the middle quarter of the frame for .15 sec. */
1060 /* We use the select system call to do the waiting, so we have to make sure
1061 it's available. If it isn't, we just won't do visual bells. */
1062 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
1064 /* Subtract the `struct timeval' values X and Y,
1065 storing the result in RESULT.
1066 Return 1 if the difference is negative, otherwise 0. */
1069 timeval_subtract (result
, x
, y
)
1070 struct timeval
*result
, x
, y
;
1072 /* Perform the carry for the later subtraction by updating y.
1073 This is safer because on some systems
1074 the tv_sec member is unsigned. */
1075 if (x
.tv_usec
< y
.tv_usec
)
1077 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
1078 y
.tv_usec
-= 1000000 * nsec
;
1081 if (x
.tv_usec
- y
.tv_usec
> 1000000)
1083 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
1084 y
.tv_usec
+= 1000000 * nsec
;
1088 /* Compute the time remaining to wait. tv_usec is certainly positive. */
1089 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
1090 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
1092 /* Return indication of whether the result should be considered negative. */
1093 return x
.tv_sec
< y
.tv_sec
;
1104 /* Create a GC that will use the GXxor function to flip foreground pixels
1105 into background pixels. */
1109 values
.function
= GXxor
;
1110 values
.foreground
= (f
->output_data
.x
->foreground_pixel
1111 ^ f
->output_data
.x
->background_pixel
);
1113 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1114 GCFunction
| GCForeground
, &values
);
1118 int width
= PIXEL_WIDTH (f
);
1119 int height
= PIXEL_HEIGHT (f
);
1121 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
1122 width
/4, height
/4, width
/2, height
/2);
1123 XFlush (FRAME_X_DISPLAY (f
));
1126 struct timeval wakeup
, now
;
1128 EMACS_GET_TIME (wakeup
);
1130 /* Compute time to wait until, propagating carry from usecs. */
1131 wakeup
.tv_usec
+= 150000;
1132 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
1133 wakeup
.tv_usec
%= 1000000;
1135 /* Keep waiting until past the time wakeup. */
1138 struct timeval timeout
;
1140 EMACS_GET_TIME (timeout
);
1142 /* In effect, timeout = wakeup - timeout.
1143 Break if result would be negative. */
1144 if (timeval_subtract (&timeout
, wakeup
, timeout
))
1147 /* Try to wait that long--but we might wake up sooner. */
1148 select (0, NULL
, NULL
, NULL
, &timeout
);
1152 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
1153 width
/4, height
/4, width
/2, height
/2);
1154 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
1155 XFlush (FRAME_X_DISPLAY (f
));
1165 /* Make audible bell. */
1167 #define XRINGBELL XBell (FRAME_X_DISPLAY (selected_frame), 0)
1171 if (FRAME_X_DISPLAY (selected_frame
) == 0)
1174 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
1176 XTflash (selected_frame
);
1182 XFlush (FRAME_X_DISPLAY (selected_frame
));
1187 /* Insert and delete character.
1188 These are not supposed to be used because we are supposed to turn
1189 off the feature of using them. */
1192 XTinsert_glyphs (start
, len
)
1193 register char *start
;
1206 /* Specify how many text lines, from the top of the window,
1207 should be affected by insert-lines and delete-lines operations.
1208 This, and those operations, are used only within an update
1209 that is bounded by calls to XTupdate_begin and XTupdate_end. */
1212 XTset_terminal_window (n
)
1215 if (updating_frame
== 0)
1218 if ((n
<= 0) || (n
> updating_frame
->height
))
1219 flexlines
= updating_frame
->height
;
1224 /* These variables need not be per frame
1225 because redisplay is done on a frame-by-frame basis
1226 and the line dance for one frame is finished before
1227 anything is done for anoter frame. */
1229 /* Array of line numbers from cached insert/delete operations.
1230 line_dance[i] is the old position of the line that we want
1231 to move to line i, or -1 if we want a blank line there. */
1232 static int *line_dance
;
1234 /* Allocated length of that array. */
1235 static int line_dance_len
;
1237 /* Flag indicating whether we've done any work. */
1238 static int line_dance_in_progress
;
1240 /* Perform an insert-lines or delete-lines operation,
1241 inserting N lines or deleting -N lines at vertical position VPOS. */
1242 XTins_del_lines (vpos
, n
)
1245 register int fence
, i
;
1247 if (vpos
>= flexlines
)
1250 if (!line_dance_in_progress
)
1252 int ht
= updating_frame
->height
;
1253 if (ht
> line_dance_len
)
1255 line_dance
= (int *)xrealloc (line_dance
, ht
* sizeof (int));
1256 line_dance_len
= ht
;
1258 for (i
= 0; i
< ht
; ++i
) line_dance
[i
] = i
;
1259 line_dance_in_progress
= 1;
1263 if (n
> flexlines
- vpos
)
1264 n
= flexlines
- vpos
;
1266 for (i
= flexlines
; --i
>= fence
;)
1267 line_dance
[i
] = line_dance
[i
-n
];
1268 for (i
= fence
; --i
>= vpos
;)
1274 if (n
> flexlines
- vpos
)
1275 n
= flexlines
- vpos
;
1276 fence
= flexlines
- n
;
1277 for (i
= vpos
; i
< fence
; ++i
)
1278 line_dance
[i
] = line_dance
[i
+ n
];
1279 for (i
= fence
; i
< flexlines
; ++i
)
1284 /* Here's where we actually move the pixels around.
1285 Must be called with input blocked. */
1289 register int i
, j
, distance
;
1290 register struct frame
*f
;
1294 /* Must check this flag first. If it's not set, then not only is the
1295 array uninitialized, but we might not even have a frame. */
1296 if (!line_dance_in_progress
)
1304 intborder
= f
->output_data
.x
->internal_border_width
;
1306 x_update_cursor (updating_frame
, 0);
1308 for (i
= 0; i
< ht
; ++i
)
1309 if (line_dance
[i
] != -1 && (distance
= line_dance
[i
]-i
) > 0)
1311 for (j
= i
; (j
< ht
&& line_dance
[j
] != -1
1312 && line_dance
[j
]-j
== distance
); ++j
);
1313 /* Copy [i,j) upward from [i+distance,j+distance) */
1314 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1315 FRAME_X_WINDOW (f
), f
->output_data
.x
->normal_gc
,
1316 intborder
, CHAR_TO_PIXEL_ROW (f
, i
+distance
),
1317 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1318 (j
-i
) * f
->output_data
.x
->line_height
,
1319 intborder
, CHAR_TO_PIXEL_ROW (f
, i
));
1323 for (i
= ht
; --i
>=0; )
1324 if (line_dance
[i
] != -1 && (distance
= line_dance
[i
]-i
) < 0)
1326 for (j
= i
; (--j
>= 0 && line_dance
[j
] != -1
1327 && line_dance
[j
]-j
== distance
););
1328 /* Copy (j,i] downward from (j+distance, i+distance] */
1329 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1330 FRAME_X_WINDOW (f
), f
->output_data
.x
->normal_gc
,
1331 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1+distance
),
1332 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1333 (i
-j
) * f
->output_data
.x
->line_height
,
1334 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1));
1338 for (i
= 0; i
< ht
; ++i
)
1339 if (line_dance
[i
] == -1)
1341 for (j
= i
; j
< ht
&& line_dance
[j
] == -1; ++j
);
1343 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1344 intborder
, CHAR_TO_PIXEL_ROW (f
, i
),
1345 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1346 (j
-i
) * f
->output_data
.x
->line_height
, False
);
1349 line_dance_in_progress
= 0;
1352 /* Support routines for exposure events. */
1353 static void clear_cursor ();
1355 /* Output into a rectangle of an X-window (for frame F)
1356 the characters in f->phys_lines that overlap that rectangle.
1357 TOP and LEFT are the position of the upper left corner of the rectangle.
1358 ROWS and COLS are the size of the rectangle.
1359 Call this function with input blocked. */
1362 dumprectangle (f
, left
, top
, cols
, rows
)
1364 register int left
, top
, cols
, rows
;
1366 register struct frame_glyphs
*active_frame
= FRAME_CURRENT_GLYPHS (f
);
1367 int cursor_cleared
= 0;
1371 if (FRAME_GARBAGED_P (f
))
1374 /* Express rectangle as four edges, instead of position-and-size. */
1375 bottom
= top
+ rows
;
1376 right
= left
+ cols
;
1378 /* Convert rectangle edges in pixels to edges in chars.
1379 Round down for left and top, up for right and bottom. */
1380 top
= PIXEL_TO_CHAR_ROW (f
, top
);
1381 left
= PIXEL_TO_CHAR_COL (f
, left
);
1382 bottom
+= (f
->output_data
.x
->line_height
- 1);
1383 right
+= (FONT_WIDTH (f
->output_data
.x
->font
) - 1);
1384 bottom
= PIXEL_TO_CHAR_ROW (f
, bottom
);
1385 right
= PIXEL_TO_CHAR_COL (f
, right
);
1387 /* Clip the rectangle to what can be visible. */
1392 if (right
> f
->width
)
1394 if (bottom
> f
->height
)
1397 /* Get size in chars of the rectangle. */
1398 cols
= right
- left
;
1399 rows
= bottom
- top
;
1401 /* If rectangle has zero area, return. */
1402 if (rows
<= 0) return;
1403 if (cols
<= 0) return;
1405 /* Turn off the cursor if it is in the rectangle.
1406 We will turn it back on afterward. */
1407 if ((f
->phys_cursor_x
>= left
) && (f
->phys_cursor_x
< right
)
1408 && (f
->phys_cursor_y
>= top
) && (f
->phys_cursor_y
< bottom
))
1414 /* Display the text in the rectangle, one text line at a time. */
1416 for (y
= top
; y
< bottom
; y
++)
1418 GLYPH
*line
= &active_frame
->glyphs
[y
][left
];
1420 if (! active_frame
->enable
[y
] || left
> active_frame
->used
[y
])
1424 CHAR_TO_PIXEL_COL (f
, left
),
1425 CHAR_TO_PIXEL_ROW (f
, y
),
1426 line
, min (cols
, active_frame
->used
[y
] - left
),
1427 active_frame
->highlight
[y
], 0);
1430 /* Turn the cursor on if we turned it off. */
1433 x_update_cursor (f
, 1);
1440 /* We used to only do this if Vx_no_window_manager was non-nil, but
1441 the ICCCM (section 4.1.6) says that the window's border pixmap
1442 and border pixel are window attributes which are "private to the
1443 client", so we can always change it to whatever we want. */
1445 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1446 f
->output_data
.x
->border_pixel
);
1448 x_update_cursor (f
, 1);
1452 frame_unhighlight (f
)
1455 /* We used to only do this if Vx_no_window_manager was non-nil, but
1456 the ICCCM (section 4.1.6) says that the window's border pixmap
1457 and border pixel are window attributes which are "private to the
1458 client", so we can always change it to whatever we want. */
1460 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1461 f
->output_data
.x
->border_tile
);
1463 x_update_cursor (f
, 1);
1466 static void XTframe_rehighlight ();
1467 static void x_frame_rehighlight ();
1469 /* The focus has changed. Update the frames as necessary to reflect
1470 the new situation. Note that we can't change the selected frame
1471 here, because the Lisp code we are interrupting might become confused.
1472 Each event gets marked with the frame in which it occurred, so the
1473 Lisp code can tell when the switch took place by examining the events. */
1476 x_new_focus_frame (dpyinfo
, frame
)
1477 struct x_display_info
*dpyinfo
;
1478 struct frame
*frame
;
1480 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
1481 int events_enqueued
= 0;
1483 if (frame
!= dpyinfo
->x_focus_frame
)
1485 /* Set this before calling other routines, so that they see
1486 the correct value of x_focus_frame. */
1487 dpyinfo
->x_focus_frame
= frame
;
1489 if (old_focus
&& old_focus
->auto_lower
)
1490 x_lower_frame (old_focus
);
1493 selected_frame
= frame
;
1494 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
1496 Fselect_window (selected_frame
->selected_window
);
1497 choose_minibuf_frame ();
1500 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
1501 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
1503 pending_autoraise_frame
= 0;
1506 x_frame_rehighlight (dpyinfo
);
1509 /* Handle an event saying the mouse has moved out of an Emacs frame. */
1512 x_mouse_leave (dpyinfo
)
1513 struct x_display_info
*dpyinfo
;
1515 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
1518 /* The focus has changed, or we have redirected a frame's focus to
1519 another frame (this happens when a frame uses a surrogate
1520 minibuffer frame). Shift the highlight as appropriate.
1522 The FRAME argument doesn't necessarily have anything to do with which
1523 frame is being highlighted or unhighlighted; we only use it to find
1524 the appropriate X display info. */
1526 XTframe_rehighlight (frame
)
1527 struct frame
*frame
;
1529 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
1533 x_frame_rehighlight (dpyinfo
)
1534 struct x_display_info
*dpyinfo
;
1536 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
1538 if (dpyinfo
->x_focus_frame
)
1540 dpyinfo
->x_highlight_frame
1541 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
1542 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
1543 : dpyinfo
->x_focus_frame
);
1544 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
1546 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
1547 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
1551 dpyinfo
->x_highlight_frame
= 0;
1553 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
1556 frame_unhighlight (old_highlight
);
1557 if (dpyinfo
->x_highlight_frame
)
1558 frame_highlight (dpyinfo
->x_highlight_frame
);
1562 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
1564 /* Initialize mode_switch_bit and modifier_meaning. */
1566 x_find_modifier_meanings (dpyinfo
)
1567 struct x_display_info
*dpyinfo
;
1569 int min_code
, max_code
;
1572 XModifierKeymap
*mods
;
1574 dpyinfo
->meta_mod_mask
= 0;
1575 dpyinfo
->shift_lock_mask
= 0;
1576 dpyinfo
->alt_mod_mask
= 0;
1577 dpyinfo
->super_mod_mask
= 0;
1578 dpyinfo
->hyper_mod_mask
= 0;
1581 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
1583 min_code
= dpyinfo
->display
->min_keycode
;
1584 max_code
= dpyinfo
->display
->max_keycode
;
1587 syms
= XGetKeyboardMapping (dpyinfo
->display
,
1588 min_code
, max_code
- min_code
+ 1,
1590 mods
= XGetModifierMapping (dpyinfo
->display
);
1592 /* Scan the modifier table to see which modifier bits the Meta and
1593 Alt keysyms are on. */
1595 int row
, col
; /* The row and column in the modifier table. */
1597 for (row
= 3; row
< 8; row
++)
1598 for (col
= 0; col
< mods
->max_keypermod
; col
++)
1601 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
1603 /* Zeroes are used for filler. Skip them. */
1607 /* Are any of this keycode's keysyms a meta key? */
1611 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
1613 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
1619 dpyinfo
->meta_mod_mask
|= (1 << row
);
1624 dpyinfo
->alt_mod_mask
|= (1 << row
);
1629 dpyinfo
->hyper_mod_mask
|= (1 << row
);
1634 dpyinfo
->super_mod_mask
|= (1 << row
);
1638 /* Ignore this if it's not on the lock modifier. */
1639 if ((1 << row
) == LockMask
)
1640 dpyinfo
->shift_lock_mask
= LockMask
;
1648 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
1649 if (! dpyinfo
->meta_mod_mask
)
1651 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
1652 dpyinfo
->alt_mod_mask
= 0;
1655 /* If some keys are both alt and meta,
1656 make them just meta, not alt. */
1657 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
1659 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
1662 XFree ((char *) syms
);
1663 XFreeModifiermap (mods
);
1666 /* Convert between the modifier bits X uses and the modifier bits
1669 x_x_to_emacs_modifiers (dpyinfo
, state
)
1670 struct x_display_info
*dpyinfo
;
1673 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
1674 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
1675 | ((state
& dpyinfo
->meta_mod_mask
) ? meta_modifier
: 0)
1676 | ((state
& dpyinfo
->alt_mod_mask
) ? alt_modifier
: 0)
1677 | ((state
& dpyinfo
->super_mod_mask
) ? super_modifier
: 0)
1678 | ((state
& dpyinfo
->hyper_mod_mask
) ? hyper_modifier
: 0));
1682 x_emacs_to_x_modifiers (dpyinfo
, state
)
1683 struct x_display_info
*dpyinfo
;
1686 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
1687 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
1688 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
1689 | ((state
& shift_modifier
) ? ShiftMask
: 0)
1690 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
1691 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
1694 /* Convert a keysym to its name. */
1697 x_get_keysym_name (keysym
)
1703 value
= XKeysymToString (keysym
);
1709 /* Mouse clicks and mouse movement. Rah. */
1711 /* Given a pixel position (PIX_X, PIX_Y) on the frame F, return
1712 glyph co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle
1713 that the glyph at X, Y occupies, if BOUNDS != 0.
1714 If NOCLIP is nonzero, do not force the value into range. */
1717 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
1719 register int pix_x
, pix_y
;
1720 register int *x
, *y
;
1724 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
1725 even for negative values. */
1727 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
1729 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
1731 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
1732 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
1736 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
1737 bounds
->height
= f
->output_data
.x
->line_height
;
1738 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
1739 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
1746 else if (pix_x
> f
->width
)
1751 else if (pix_y
> f
->height
)
1760 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
1763 register int *pix_x
, *pix_y
;
1765 *pix_x
= CHAR_TO_PIXEL_COL (f
, x
);
1766 *pix_y
= CHAR_TO_PIXEL_ROW (f
, y
);
1769 /* Prepare a mouse-event in *RESULT for placement in the input queue.
1771 If the event is a button press, then note that we have grabbed
1775 construct_mouse_click (result
, event
, f
)
1776 struct input_event
*result
;
1777 XButtonEvent
*event
;
1780 /* Make the event type no_event; we'll change that when we decide
1782 result
->kind
= mouse_click
;
1783 result
->code
= event
->button
- Button1
;
1784 result
->timestamp
= event
->time
;
1785 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
1787 | (event
->type
== ButtonRelease
1795 pixel_to_glyph_coords (f
, event
->x
, event
->y
, &column
, &row
, NULL
, 0);
1796 XSETFASTINT (result
->x
, column
);
1797 XSETFASTINT (result
->y
, row
);
1799 XSETINT (result
->x
, event
->x
);
1800 XSETINT (result
->y
, event
->y
);
1801 XSETFRAME (result
->frame_or_window
, f
);
1805 /* Prepare a menu-event in *RESULT for placement in the input queue. */
1808 construct_menu_click (result
, event
, f
)
1809 struct input_event
*result
;
1810 XButtonEvent
*event
;
1813 /* Make the event type no_event; we'll change that when we decide
1815 result
->kind
= mouse_click
;
1816 XSETINT (result
->code
, event
->button
- Button1
);
1817 result
->timestamp
= event
->time
;
1818 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
1820 | (event
->type
== ButtonRelease
1824 XSETINT (result
->x
, event
->x
);
1825 XSETINT (result
->y
, -1);
1826 XSETFRAME (result
->frame_or_window
, f
);
1829 /* Function to report a mouse movement to the mainstream Emacs code.
1830 The input handler calls this.
1832 We have received a mouse movement event, which is given in *event.
1833 If the mouse is over a different glyph than it was last time, tell
1834 the mainstream emacs code by setting mouse_moved. If not, ask for
1835 another motion event, so we can check again the next time it moves. */
1838 note_mouse_movement (frame
, event
)
1840 XMotionEvent
*event
;
1842 last_mouse_movement_time
= event
->time
;
1844 if (event
->window
!= FRAME_X_WINDOW (frame
))
1846 frame
->mouse_moved
= 1;
1847 last_mouse_scroll_bar
= Qnil
;
1849 note_mouse_highlight (frame
, -1, -1);
1852 /* Has the mouse moved off the glyph it was on at the last sighting? */
1853 else if (event
->x
< last_mouse_glyph
.x
1854 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
1855 || event
->y
< last_mouse_glyph
.y
1856 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
1858 frame
->mouse_moved
= 1;
1859 last_mouse_scroll_bar
= Qnil
;
1861 note_mouse_highlight (frame
, event
->x
, event
->y
);
1865 /* This is used for debugging, to turn off note_mouse_highlight. */
1866 static int disable_mouse_highlight
;
1868 /* Take proper action when the mouse has moved to position X, Y on frame F
1869 as regards highlighting characters that have mouse-face properties.
1870 Also dehighlighting chars where the mouse was before.
1871 X and Y can be negative or out of range. */
1874 note_mouse_highlight (f
, x
, y
)
1878 int row
, column
, portion
;
1879 XRectangle new_glyph
;
1883 if (disable_mouse_highlight
)
1886 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
= x
;
1887 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
= y
;
1888 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
= f
;
1890 if (FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
)
1895 FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 1;
1899 /* Find out which glyph the mouse is on. */
1900 pixel_to_glyph_coords (f
, x
, y
, &column
, &row
,
1901 &new_glyph
, FRAME_X_DISPLAY_INFO (f
)->grabbed
);
1903 /* Which window is that in? */
1904 window
= window_from_coordinates (f
, column
, row
, &portion
);
1905 w
= XWINDOW (window
);
1907 /* If we were displaying active text in another window, clear that. */
1908 if (! EQ (window
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
))
1909 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1911 /* Are we in a window whose display is up to date?
1912 And verify the buffer's text has not changed. */
1913 if (WINDOWP (window
) && portion
== 0 && row
>= 0 && column
>= 0
1914 && row
< FRAME_HEIGHT (f
) && column
< FRAME_WIDTH (f
)
1915 && EQ (w
->window_end_valid
, w
->buffer
)
1916 && w
->last_modified
== BUF_MODIFF (XBUFFER (w
->buffer
))
1917 && w
->last_overlay_modified
== BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
)))
1919 int *ptr
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[row
];
1922 /* Find which buffer position the mouse corresponds to. */
1923 for (i
= column
; i
>= 0; i
--)
1927 /* Is it outside the displayed active region (if any)? */
1929 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1930 else if (! (EQ (window
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
)
1931 && row
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
1932 && row
<= FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
1933 && (row
> FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
1934 || column
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
)
1935 && (row
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
1936 || column
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
1937 || FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
)))
1939 Lisp_Object mouse_face
, overlay
, position
;
1940 Lisp_Object
*overlay_vec
;
1941 int len
, noverlays
, ignor1
;
1942 struct buffer
*obuf
;
1945 /* If we get an out-of-range value, return now; avoid an error. */
1946 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1949 /* Make the window's buffer temporarily current for
1950 overlays_at and compute_char_face. */
1951 obuf
= current_buffer
;
1952 current_buffer
= XBUFFER (w
->buffer
);
1958 /* Yes. Clear the display of the old active region, if any. */
1959 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1961 /* Is this char mouse-active? */
1962 XSETINT (position
, pos
);
1965 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1967 /* Put all the overlays we want in a vector in overlay_vec.
1968 Store the length in len. */
1969 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
1971 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1973 /* Find the highest priority overlay that has a mouse-face prop. */
1975 for (i
= 0; i
< noverlays
; i
++)
1977 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1978 if (!NILP (mouse_face
))
1980 overlay
= overlay_vec
[i
];
1985 /* If no overlay applies, get a text property. */
1987 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
1989 /* Handle the overlay case. */
1990 if (! NILP (overlay
))
1992 /* Find the range of text around this char that
1993 should be active. */
1994 Lisp_Object before
, after
;
1997 before
= Foverlay_start (overlay
);
1998 after
= Foverlay_end (overlay
);
1999 /* Record this as the current active region. */
2000 fast_find_position (window
, XFASTINT (before
),
2001 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
,
2002 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
);
2003 FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
2004 = !fast_find_position (window
, XFASTINT (after
),
2005 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
,
2006 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
);
2007 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= window
;
2008 FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
2009 = compute_char_face (f
, w
, pos
, 0, 0,
2010 &ignore
, pos
+ 1, 1);
2012 /* Display it as active. */
2013 show_mouse_face (FRAME_X_DISPLAY_INFO (f
), 1);
2015 /* Handle the text property case. */
2016 else if (! NILP (mouse_face
))
2018 /* Find the range of text around this char that
2019 should be active. */
2020 Lisp_Object before
, after
, beginning
, end
;
2023 beginning
= Fmarker_position (w
->start
);
2024 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
2025 - XFASTINT (w
->window_end_pos
)));
2027 = Fprevious_single_property_change (make_number (pos
+ 1),
2029 w
->buffer
, beginning
);
2031 = Fnext_single_property_change (position
, Qmouse_face
,
2033 /* Record this as the current active region. */
2034 fast_find_position (window
, XFASTINT (before
),
2035 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
,
2036 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
);
2037 FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
2038 = !fast_find_position (window
, XFASTINT (after
),
2039 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
,
2040 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
);
2041 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= window
;
2042 FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
2043 = compute_char_face (f
, w
, pos
, 0, 0,
2044 &ignore
, pos
+ 1, 1);
2046 /* Display it as active. */
2047 show_mouse_face (FRAME_X_DISPLAY_INFO (f
), 1);
2051 current_buffer
= obuf
;
2056 /* Find the row and column of position POS in window WINDOW.
2057 Store them in *COLUMNP and *ROWP.
2058 This assumes display in WINDOW is up to date.
2059 If POS is above start of WINDOW, return coords
2060 of start of first screen line.
2061 If POS is after end of WINDOW, return coords of end of last screen line.
2063 Value is 1 if POS is in range, 0 if it was off screen. */
2066 fast_find_position (window
, pos
, columnp
, rowp
)
2069 int *columnp
, *rowp
;
2071 struct window
*w
= XWINDOW (window
);
2072 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2077 int height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
2078 int width
= window_internal_width (w
);
2081 int maybe_next_line
= 0;
2083 /* Find the right row. */
2088 int linestart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ i
][left
];
2089 if (linestart
> pos
)
2091 /* If the position sought is the end of the buffer,
2092 don't include the blank lines at the bottom of the window. */
2093 if (linestart
== pos
&& pos
== BUF_ZV (XBUFFER (w
->buffer
)))
2095 maybe_next_line
= 1;
2102 /* Find the right column with in it. */
2103 charstarts
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ row
];
2105 for (i
= 0; i
< width
; i
++)
2107 if (charstarts
[left
+ i
] == pos
)
2110 *columnp
= i
+ left
;
2113 else if (charstarts
[left
+ i
] > pos
)
2115 else if (charstarts
[left
+ i
] > 0)
2119 /* If we're looking for the end of the buffer,
2120 and we didn't find it in the line we scanned,
2121 use the start of the following line. */
2122 if (maybe_next_line
)
2133 /* Display the active region described by mouse_face_*
2134 in its mouse-face if HL > 0, in its normal face if HL = 0. */
2137 show_mouse_face (dpyinfo
, hl
)
2138 struct x_display_info
*dpyinfo
;
2141 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
2142 int width
= window_internal_width (w
);
2143 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2147 for (i
= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
;
2148 i
<= FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
; i
++)
2150 int column
= (i
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
2151 ? FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
2153 int endcolumn
= (i
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
2154 ? FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
2156 endcolumn
= min (endcolumn
, FRAME_CURRENT_GLYPHS (f
)->used
[i
]);
2158 /* If the cursor's in the text we are about to rewrite,
2159 turn the cursor off. */
2161 && curs_x
>= column
- 1
2162 && curs_x
<= endcolumn
)
2164 x_update_cursor (f
, 0);
2169 CHAR_TO_PIXEL_COL (f
, column
),
2170 CHAR_TO_PIXEL_ROW (f
, i
),
2171 FRAME_CURRENT_GLYPHS (f
)->glyphs
[i
] + column
,
2173 /* Highlight with mouse face if hl > 0. */
2177 /* If we turned the cursor off, turn it back on. */
2179 x_update_cursor (f
, 1);
2181 /* Change the mouse cursor according to the value of HL. */
2183 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2184 f
->output_data
.x
->cross_cursor
);
2186 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2187 f
->output_data
.x
->text_cursor
);
2190 /* Clear out the mouse-highlighted active region.
2191 Redraw it unhighlighted first. */
2194 clear_mouse_face (dpyinfo
)
2195 struct x_display_info
*dpyinfo
;
2197 if (! NILP (dpyinfo
->mouse_face_window
))
2198 show_mouse_face (dpyinfo
, 0);
2200 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
2201 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
2202 dpyinfo
->mouse_face_window
= Qnil
;
2205 static struct scroll_bar
*x_window_to_scroll_bar ();
2206 static void x_scroll_bar_report_motion ();
2208 /* Return the current position of the mouse.
2209 *fp should be a frame which indicates which display to ask about.
2211 If the mouse movement started in a scroll bar, set *fp, *bar_window,
2212 and *part to the frame, window, and scroll bar part that the mouse
2213 is over. Set *x and *y to the portion and whole of the mouse's
2214 position on the scroll bar.
2216 If the mouse movement started elsewhere, set *fp to the frame the
2217 mouse is on, *bar_window to nil, and *x and *y to the character cell
2220 Set *time to the server timestamp for the time at which the mouse
2221 was at this position.
2223 Don't store anything if we don't have a valid set of values to report.
2225 This clears the mouse_moved flag, so we can wait for the next mouse
2229 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
2232 Lisp_Object
*bar_window
;
2233 enum scroll_bar_part
*part
;
2235 unsigned long *time
;
2241 if (! NILP (last_mouse_scroll_bar
))
2242 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
2248 Window dummy_window
;
2251 Lisp_Object frame
, tail
;
2253 /* Clear the mouse-moved flag for every frame on this display. */
2254 FOR_EACH_FRAME (tail
, frame
)
2255 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
2256 XFRAME (frame
)->mouse_moved
= 0;
2258 last_mouse_scroll_bar
= Qnil
;
2260 /* Figure out which root window we're on. */
2261 XQueryPointer (FRAME_X_DISPLAY (*fp
),
2262 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
2264 /* The root window which contains the pointer. */
2267 /* Trash which we can't trust if the pointer is on
2268 a different screen. */
2271 /* The position on that root window. */
2274 /* More trash we can't trust. */
2277 /* Modifier keys and pointer buttons, about which
2279 (unsigned int *) &dummy
);
2281 /* Now we have a position on the root; find the innermost window
2282 containing the pointer. */
2286 int parent_x
, parent_y
;
2290 /* XTranslateCoordinates can get errors if the window
2291 structure is changing at the same time this function
2292 is running. So at least we must not crash from them. */
2294 x_catch_errors (FRAME_X_DISPLAY (*fp
));
2296 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
2297 && FRAME_LIVE_P (last_mouse_frame
))
2299 /* If mouse was grabbed on a frame, give coords for that frame
2300 even if the mouse is now outside it. */
2301 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
2303 /* From-window, to-window. */
2304 root
, FRAME_X_WINDOW (last_mouse_frame
),
2306 /* From-position, to-position. */
2307 root_x
, root_y
, &win_x
, &win_y
,
2311 f1
= last_mouse_frame
;
2317 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
2319 /* From-window, to-window. */
2322 /* From-position, to-position. */
2323 root_x
, root_y
, &win_x
, &win_y
,
2328 if (child
== None
|| child
== win
)
2336 /* Now we know that:
2337 win is the innermost window containing the pointer
2338 (XTC says it has no child containing the pointer),
2339 win_x and win_y are the pointer's position in it
2340 (XTC did this the last time through), and
2341 parent_x and parent_y are the pointer's position in win's parent.
2342 (They are what win_x and win_y were when win was child.
2343 If win is the root window, it has no parent, and
2344 parent_{x,y} are invalid, but that's okay, because we'll
2345 never use them in that case.) */
2347 /* Is win one of our frames? */
2348 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
2351 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
2354 x_uncatch_errors (FRAME_X_DISPLAY (*fp
));
2356 /* If not, is it one of our scroll bars? */
2359 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
2363 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2369 if (f1
== 0 && insist
)
2370 f1
= selected_frame
;
2374 int ignore1
, ignore2
;
2376 /* Ok, we found a frame. Store all the values. */
2378 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
2380 FRAME_X_DISPLAY_INFO (f1
)->grabbed
2386 XSETINT (*x
, win_x
);
2387 XSETINT (*y
, win_y
);
2388 *time
= last_mouse_movement_time
;
2396 /* Scroll bar support. */
2398 /* Given an X window ID, find the struct scroll_bar which manages it.
2399 This can be called in GC, so we have to make sure to strip off mark
2401 static struct scroll_bar
*
2402 x_window_to_scroll_bar (window_id
)
2405 Lisp_Object tail
, frame
;
2407 for (tail
= Vframe_list
;
2408 XGCTYPE (tail
) == Lisp_Cons
;
2409 tail
= XCONS (tail
)->cdr
)
2411 Lisp_Object frame
, bar
, condemned
;
2413 frame
= XCONS (tail
)->car
;
2414 /* All elements of Vframe_list should be frames. */
2415 if (! GC_FRAMEP (frame
))
2418 /* Scan this frame's scroll bar list for a scroll bar with the
2420 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
2421 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
2422 /* This trick allows us to search both the ordinary and
2423 condemned scroll bar lists with one loop. */
2424 ! GC_NILP (bar
) || (bar
= condemned
,
2427 bar
= XSCROLL_BAR (bar
)->next
)
2428 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
2429 return XSCROLL_BAR (bar
);
2435 /* Open a new X window to serve as a scroll bar, and return the
2436 scroll bar vector for it. */
2437 static struct scroll_bar
*
2438 x_scroll_bar_create (window
, top
, left
, width
, height
)
2439 struct window
*window
;
2440 int top
, left
, width
, height
;
2442 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2443 struct scroll_bar
*bar
2444 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
2449 XSetWindowAttributes a
;
2451 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
2452 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
2453 | ButtonMotionMask
| PointerMotionHintMask
2455 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
2457 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
2462 XtSetArg (al
[ac
], XtNx
, left
); ac
++;
2463 XtSetArg (al
[ac
], XtNy
, top
); ac
++;
2464 XtSetArg (al
[ac
], XtNwidth
, width
); ac
++;
2465 XtSetArg (al
[ac
], XtNheight
, height
); ac
++;
2466 XtSetArg (al
[ac
], XtNborderWidth
, 0); ac
++;
2467 sb_widget
= XtCreateManagedWidget ("box",
2469 f
->output_data
.x
->edit_widget
, al
, ac
);
2470 SET_SCROLL_BAR_X_WINDOW
2471 (bar
, sb_widget
->core
.window
);
2473 SET_SCROLL_BAR_X_WINDOW
2475 XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2477 /* Position and size of scroll bar. */
2478 left
, top
, width
, height
,
2480 /* Border width, depth, class, and visual. */
2481 0, CopyFromParent
, CopyFromParent
, CopyFromParent
,
2487 XSETWINDOW (bar
->window
, window
);
2488 XSETINT (bar
->top
, top
);
2489 XSETINT (bar
->left
, left
);
2490 XSETINT (bar
->width
, width
);
2491 XSETINT (bar
->height
, height
);
2492 XSETINT (bar
->start
, 0);
2493 XSETINT (bar
->end
, 0);
2494 bar
->dragging
= Qnil
;
2496 /* Add bar to its frame's list of scroll bars. */
2497 bar
->next
= FRAME_SCROLL_BARS (f
);
2499 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2500 if (! NILP (bar
->next
))
2501 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2503 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
2510 /* Draw BAR's handle in the proper position.
2511 If the handle is already drawn from START to END, don't bother
2512 redrawing it, unless REBUILD is non-zero; in that case, always
2513 redraw it. (REBUILD is handy for drawing the handle after expose
2516 Normally, we want to constrain the start and end of the handle to
2517 fit inside its rectangle, but if the user is dragging the scroll bar
2518 handle, we want to let them drag it down all the way, so that the
2519 bar's top is as far down as it goes; otherwise, there's no way to
2520 move to the very end of the buffer. */
2522 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
2523 struct scroll_bar
*bar
;
2527 int dragging
= ! NILP (bar
->dragging
);
2528 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2529 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2530 GC gc
= f
->output_data
.x
->normal_gc
;
2532 /* If the display is already accurate, do nothing. */
2534 && start
== XINT (bar
->start
)
2535 && end
== XINT (bar
->end
))
2541 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (XINT (bar
->width
));
2542 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2543 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2545 /* Make sure the values are reasonable, and try to preserve
2546 the distance between start and end. */
2548 int length
= end
- start
;
2552 else if (start
> top_range
)
2554 end
= start
+ length
;
2558 else if (end
> top_range
&& ! dragging
)
2562 /* Store the adjusted setting in the scroll bar. */
2563 XSETINT (bar
->start
, start
);
2564 XSETINT (bar
->end
, end
);
2566 /* Clip the end position, just for display. */
2567 if (end
> top_range
)
2570 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
2571 below top positions, to make sure the handle is always at least
2572 that many pixels tall. */
2573 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
2575 /* Draw the empty space above the handle. Note that we can't clear
2576 zero-height areas; that means "clear to end of window." */
2578 XClearArea (FRAME_X_DISPLAY (f
), w
,
2580 /* x, y, width, height, and exposures. */
2581 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2582 VERTICAL_SCROLL_BAR_TOP_BORDER
,
2583 inside_width
, start
,
2586 /* Draw the handle itself. */
2587 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
2589 /* x, y, width, height */
2590 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2591 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
2592 inside_width
, end
- start
);
2595 /* Draw the empty space below the handle. Note that we can't
2596 clear zero-height areas; that means "clear to end of window." */
2597 if (end
< inside_height
)
2598 XClearArea (FRAME_X_DISPLAY (f
), w
,
2600 /* x, y, width, height, and exposures. */
2601 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2602 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
2603 inside_width
, inside_height
- end
,
2611 /* Move a scroll bar around on the screen, to accommodate changing
2612 window configurations. */
2614 x_scroll_bar_move (bar
, top
, left
, width
, height
)
2615 struct scroll_bar
*bar
;
2616 int top
, left
, width
, height
;
2618 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2619 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2625 unsigned int mask
= 0;
2632 if (left
!= XINT (bar
->left
)) mask
|= CWX
;
2633 if (top
!= XINT (bar
->top
)) mask
|= CWY
;
2634 if (width
!= XINT (bar
->width
)) mask
|= CWWidth
;
2635 if (height
!= XINT (bar
->height
)) mask
|= CWHeight
;
2638 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
2642 XSETINT (bar
->left
, left
);
2643 XSETINT (bar
->top
, top
);
2644 XSETINT (bar
->width
, width
);
2645 XSETINT (bar
->height
, height
);
2650 /* Destroy the X window for BAR, and set its Emacs window's scroll bar
2653 x_scroll_bar_remove (bar
)
2654 struct scroll_bar
*bar
;
2656 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2660 /* Destroy the window. */
2661 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
2663 /* Disassociate this scroll bar from its window. */
2664 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
2669 /* Set the handle of the vertical scroll bar for WINDOW to indicate
2670 that we are displaying PORTION characters out of a total of WHOLE
2671 characters, starting at POSITION. If WINDOW has no scroll bar,
2674 XTset_vertical_scroll_bar (window
, portion
, whole
, position
)
2675 struct window
*window
;
2676 int portion
, whole
, position
;
2678 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2679 int top
= XINT (window
->top
);
2680 int left
= WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window
);
2681 int height
= WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window
);
2683 /* Where should this scroll bar be, pixelwise? */
2684 int pixel_top
= CHAR_TO_PIXEL_ROW (f
, top
);
2685 int pixel_left
= CHAR_TO_PIXEL_COL (f
, left
);
2687 = (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
2688 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
2689 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
2690 int pixel_height
= VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f
, height
);
2692 struct scroll_bar
*bar
;
2694 /* Does the scroll bar exist yet? */
2695 if (NILP (window
->vertical_scroll_bar
))
2696 bar
= x_scroll_bar_create (window
,
2697 pixel_top
, pixel_left
,
2698 pixel_width
, pixel_height
);
2701 /* It may just need to be moved and resized. */
2702 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2703 x_scroll_bar_move (bar
, pixel_top
, pixel_left
, pixel_width
, pixel_height
);
2706 /* Set the scroll bar's current state, unless we're currently being
2708 if (NILP (bar
->dragging
))
2710 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height
);
2713 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
2716 int start
= ((double) position
* top_range
) / whole
;
2717 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
2719 x_scroll_bar_set_handle (bar
, start
, end
, 0);
2723 XSETVECTOR (window
->vertical_scroll_bar
, bar
);
2727 /* The following three hooks are used when we're doing a thorough
2728 redisplay of the frame. We don't explicitly know which scroll bars
2729 are going to be deleted, because keeping track of when windows go
2730 away is a real pain - "Can you say set-window-configuration, boys
2731 and girls?" Instead, we just assert at the beginning of redisplay
2732 that *all* scroll bars are to be removed, and then save a scroll bar
2733 from the fiery pit when we actually redisplay its window. */
2735 /* Arrange for all scroll bars on FRAME to be removed at the next call
2736 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
2737 `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
2739 XTcondemn_scroll_bars (frame
)
2742 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
2743 while (! NILP (FRAME_SCROLL_BARS (frame
)))
2746 bar
= FRAME_SCROLL_BARS (frame
);
2747 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
2748 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
2749 XSCROLL_BAR (bar
)->prev
= Qnil
;
2750 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
2751 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
2752 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
2756 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
2757 Note that WINDOW isn't necessarily condemned at all. */
2759 XTredeem_scroll_bar (window
)
2760 struct window
*window
;
2762 struct scroll_bar
*bar
;
2764 /* We can't redeem this window's scroll bar if it doesn't have one. */
2765 if (NILP (window
->vertical_scroll_bar
))
2768 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2770 /* Unlink it from the condemned list. */
2772 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2774 if (NILP (bar
->prev
))
2776 /* If the prev pointer is nil, it must be the first in one of
2778 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
2779 /* It's not condemned. Everything's fine. */
2781 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
2782 window
->vertical_scroll_bar
))
2783 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
2785 /* If its prev pointer is nil, it must be at the front of
2786 one or the other! */
2790 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
2792 if (! NILP (bar
->next
))
2793 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
2795 bar
->next
= FRAME_SCROLL_BARS (f
);
2797 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2798 if (! NILP (bar
->next
))
2799 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2803 /* Remove all scroll bars on FRAME that haven't been saved since the
2804 last call to `*condemn_scroll_bars_hook'. */
2806 XTjudge_scroll_bars (f
)
2809 Lisp_Object bar
, next
;
2811 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
2813 /* Clear out the condemned list now so we won't try to process any
2814 more events on the hapless scroll bars. */
2815 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
2817 for (; ! NILP (bar
); bar
= next
)
2819 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
2821 x_scroll_bar_remove (b
);
2824 b
->next
= b
->prev
= Qnil
;
2827 /* Now there should be no references to the condemned scroll bars,
2828 and they should get garbage-collected. */
2832 /* Handle an Expose or GraphicsExpose event on a scroll bar.
2834 This may be called from a signal handler, so we have to ignore GC
2837 x_scroll_bar_expose (bar
, event
)
2838 struct scroll_bar
*bar
;
2841 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2842 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2843 GC gc
= f
->output_data
.x
->normal_gc
;
2847 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
2849 /* Draw a one-pixel border just inside the edges of the scroll bar. */
2850 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
2852 /* x, y, width, height */
2853 0, 0, XINT (bar
->width
) - 1, XINT (bar
->height
) - 1);
2858 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
2859 is set to something other than no_event, it is enqueued.
2861 This may be called from a signal handler, so we have to ignore GC
2864 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
2865 struct scroll_bar
*bar
;
2867 struct input_event
*emacs_event
;
2869 if (! GC_WINDOWP (bar
->window
))
2872 emacs_event
->kind
= scroll_bar_click
;
2873 emacs_event
->code
= event
->xbutton
.button
- Button1
;
2874 emacs_event
->modifiers
2875 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
2876 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
2877 event
->xbutton
.state
)
2878 | (event
->type
== ButtonRelease
2881 emacs_event
->frame_or_window
= bar
->window
;
2882 emacs_event
->timestamp
= event
->xbutton
.time
;
2885 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2887 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2888 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
2891 if (y
> top_range
) y
= top_range
;
2893 if (y
< XINT (bar
->start
))
2894 emacs_event
->part
= scroll_bar_above_handle
;
2895 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
2896 emacs_event
->part
= scroll_bar_handle
;
2898 emacs_event
->part
= scroll_bar_below_handle
;
2900 /* Just because the user has clicked on the handle doesn't mean
2901 they want to drag it. Lisp code needs to be able to decide
2902 whether or not we're dragging. */
2904 /* If the user has just clicked on the handle, record where they're
2906 if (event
->type
== ButtonPress
2907 && emacs_event
->part
== scroll_bar_handle
)
2908 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
2911 /* If the user has released the handle, set it to its final position. */
2912 if (event
->type
== ButtonRelease
2913 && ! NILP (bar
->dragging
))
2915 int new_start
= y
- XINT (bar
->dragging
);
2916 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2918 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2919 bar
->dragging
= Qnil
;
2922 /* Same deal here as the other #if 0. */
2924 /* Clicks on the handle are always reported as occurring at the top of
2926 if (emacs_event
->part
== scroll_bar_handle
)
2927 emacs_event
->x
= bar
->start
;
2929 XSETINT (emacs_event
->x
, y
);
2931 XSETINT (emacs_event
->x
, y
);
2934 XSETINT (emacs_event
->y
, top_range
);
2938 /* Handle some mouse motion while someone is dragging the scroll bar.
2940 This may be called from a signal handler, so we have to ignore GC
2943 x_scroll_bar_note_movement (bar
, event
)
2944 struct scroll_bar
*bar
;
2947 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
2949 last_mouse_movement_time
= event
->xmotion
.time
;
2952 XSETVECTOR (last_mouse_scroll_bar
, bar
);
2954 /* If we're dragging the bar, display it. */
2955 if (! GC_NILP (bar
->dragging
))
2957 /* Where should the handle be now? */
2958 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
2960 if (new_start
!= XINT (bar
->start
))
2962 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2964 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2969 /* Return information to the user about the current position of the mouse
2970 on the scroll bar. */
2972 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
2974 Lisp_Object
*bar_window
;
2975 enum scroll_bar_part
*part
;
2977 unsigned long *time
;
2979 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
2980 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2981 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2983 Window dummy_window
;
2985 unsigned int dummy_mask
;
2989 /* Get the mouse's position relative to the scroll bar window, and
2991 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
2993 /* Root, child, root x and root y. */
2994 &dummy_window
, &dummy_window
,
2995 &dummy_coord
, &dummy_coord
,
2997 /* Position relative to scroll bar. */
3000 /* Mouse buttons and modifier keys. */
3006 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
3008 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
3010 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
3012 if (! NILP (bar
->dragging
))
3013 win_y
-= XINT (bar
->dragging
);
3017 if (win_y
> top_range
)
3021 *bar_window
= bar
->window
;
3023 if (! NILP (bar
->dragging
))
3024 *part
= scroll_bar_handle
;
3025 else if (win_y
< XINT (bar
->start
))
3026 *part
= scroll_bar_above_handle
;
3027 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
3028 *part
= scroll_bar_handle
;
3030 *part
= scroll_bar_below_handle
;
3032 XSETINT (*x
, win_y
);
3033 XSETINT (*y
, top_range
);
3036 last_mouse_scroll_bar
= Qnil
;
3039 *time
= last_mouse_movement_time
;
3045 /* The screen has been cleared so we may have changed foreground or
3046 background colors, and the scroll bars may need to be redrawn.
3047 Clear out the scroll bars, and ask for expose events, so we can
3050 x_scroll_bar_clear (f
)
3055 /* We can have scroll bars even if this is 0,
3056 if we just turned off scroll bar mode.
3057 But in that case we should not clear them. */
3058 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3059 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
3060 bar
= XSCROLL_BAR (bar
)->next
)
3061 XClearArea (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
3065 /* This processes Expose events from the menubar specific X event
3066 loop in xmenu.c. This allows to redisplay the frame if necessary
3067 when handling menubar or popup items. */
3070 process_expose_from_menu (event
)
3074 struct x_display_info
*dpyinfo
;
3078 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
3079 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
3082 if (f
->async_visible
== 0)
3084 f
->async_visible
= 1;
3085 f
->async_iconified
= 0;
3086 SET_FRAME_GARBAGED (f
);
3090 dumprectangle (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
3091 event
.xexpose
.x
, event
.xexpose
.y
,
3092 event
.xexpose
.width
, event
.xexpose
.height
);
3097 struct scroll_bar
*bar
3098 = x_window_to_scroll_bar (event
.xexpose
.window
);
3101 x_scroll_bar_expose (bar
, &event
);
3107 /* Define a queue to save up SelectionRequest events for later handling. */
3109 struct selection_event_queue
3112 struct selection_event_queue
*next
;
3115 static struct selection_event_queue
*queue
;
3117 /* Nonzero means queue up certain events--don't process them yet. */
3118 static int x_queue_selection_requests
;
3120 /* Queue up an X event *EVENT, to be processed later. */
3123 x_queue_event (f
, event
)
3127 struct selection_event_queue
*queue_tmp
3128 = (struct selection_event_queue
*) malloc (sizeof (struct selection_event_queue
));
3130 if (queue_tmp
!= NULL
)
3132 queue_tmp
->event
= *event
;
3133 queue_tmp
->next
= queue
;
3138 /* Take all the queued events and put them back
3139 so that they get processed afresh. */
3142 x_unqueue_events (display
)
3145 while (queue
!= NULL
)
3147 struct selection_event_queue
*queue_tmp
= queue
;
3148 XPutBackEvent (display
, &queue_tmp
->event
);
3149 queue
= queue_tmp
->next
;
3150 free ((char *)queue_tmp
);
3154 /* Start queuing SelectionRequest events. */
3157 x_start_queuing_selection_requests (display
)
3160 x_queue_selection_requests
++;
3163 /* Stop queuing SelectionRequest events. */
3166 x_stop_queuing_selection_requests (display
)
3169 x_queue_selection_requests
--;
3170 x_unqueue_events (display
);
3173 /* The main X event-reading loop - XTread_socket. */
3175 /* Timestamp of enter window event. This is only used by XTread_socket,
3176 but we have to put it out here, since static variables within functions
3177 sometimes don't work. */
3178 static Time enter_timestamp
;
3180 /* This holds the state XLookupString needs to implement dead keys
3181 and other tricks known as "compose processing". _X Window System_
3182 says that a portable program can't use this, but Stephen Gildea assures
3183 me that letting the compiler initialize it to zeros will work okay.
3185 This must be defined outside of XTread_socket, for the same reasons
3186 given for enter_timestamp, above. */
3187 static XComposeStatus compose_status
;
3189 /* Record the last 100 characters stored
3190 to help debug the loss-of-chars-during-GC problem. */
3191 static int temp_index
;
3192 static short temp_buffer
[100];
3194 /* Set this to nonzero to fake an "X I/O error"
3195 on a particular display. */
3196 struct x_display_info
*XTread_socket_fake_io_error
;
3198 /* When we find no input here, we occasionally do a no-op command
3199 to verify that the X server is still running and we can still talk with it.
3200 We try all the open displays, one by one.
3201 This variable is used for cycling thru the displays. */
3202 static struct x_display_info
*next_noop_dpyinfo
;
3204 #define SET_SAVED_MENU_EVENT(size) { \
3205 if (f->output_data.x->saved_menu_event == 0) \
3206 f->output_data.x->saved_menu_event = (XEvent*)xmalloc (sizeof (XEvent)); \
3207 bcopy (&event, f->output_data.x->saved_menu_event, size); \
3208 if (numchars >= 1) \
3210 bufp->kind = menu_bar_activate_event; \
3211 XSETFRAME (bufp->frame_or_window, f); \
3217 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
3218 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
3220 /* Read events coming from the X server.
3221 This routine is called by the SIGIO handler.
3222 We return as soon as there are no more events to be read.
3224 Events representing keys are stored in buffer BUFP,
3225 which can hold up to NUMCHARS characters.
3226 We return the number of characters stored into the buffer,
3227 thus pretending to be `read'.
3229 WAITP is nonzero if we should block until input arrives.
3230 EXPECTED is nonzero if the caller knows input is available. */
3233 XTread_socket (sd
, bufp
, numchars
, waitp
, expected
)
3235 /* register */ struct input_event
*bufp
;
3236 /* register */ int numchars
;
3243 int items_pending
; /* How many items are in the X queue. */
3246 int event_found
= 0;
3249 struct x_display_info
*dpyinfo
;
3251 Status status_return
;
3254 if (interrupt_input_blocked
)
3256 interrupt_input_pending
= 1;
3260 interrupt_input_pending
= 0;
3263 /* So people can tell when we have read the available input. */
3264 input_signal_count
++;
3267 abort (); /* Don't think this happens. */
3269 /* Find the display we are supposed to read input for.
3270 It's the one communicating on descriptor SD. */
3271 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
3273 #if 0 /* This ought to be unnecessary; let's verify it. */
3275 /* If available, Xlib uses FIOSNBIO to make the socket
3276 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
3277 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
3278 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
3279 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
3280 #endif /* ! defined (FIOSNBIO) */
3283 #if 0 /* This code can't be made to work, with multiple displays,
3284 and appears not to be used on any system any more.
3285 Also keyboard.c doesn't turn O_NDELAY on and off
3286 for X connections. */
3289 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
3291 extern int read_alarm_should_throw
;
3292 read_alarm_should_throw
= 1;
3293 XPeekEvent (dpyinfo
->display
, &event
);
3294 read_alarm_should_throw
= 0;
3296 #endif /* HAVE_SELECT */
3300 /* For debugging, this gives a way to fake an I/O error. */
3301 if (dpyinfo
== XTread_socket_fake_io_error
)
3303 XTread_socket_fake_io_error
= 0;
3304 x_io_error_quitter (dpyinfo
->display
);
3307 while (XPending (dpyinfo
->display
) != 0)
3309 #ifdef USE_X_TOOLKIT
3310 /* needed to raise Motif submenus */
3311 XtAppNextEvent (Xt_app_con
, &event
);
3313 XNextEvent (dpyinfo
->display
, &event
);
3317 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
3318 &event
.xclient
.window
);
3319 /* The necessity of the following line took me
3320 a full work-day to decipher from the docs!! */
3321 if (f1
!= 0 && FRAME_XIC (f1
) && XFilterEvent (&event
, None
))
3331 if (event
.xclient
.message_type
3332 == dpyinfo
->Xatom_wm_protocols
3333 && event
.xclient
.format
== 32)
3335 if (event
.xclient
.data
.l
[0]
3336 == dpyinfo
->Xatom_wm_take_focus
)
3338 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
3339 /* Since we set WM_TAKE_FOCUS, we must call
3340 XSetInputFocus explicitly. But not if f is null,
3341 since that might be an event for a deleted frame. */
3343 /* Not quite sure this is needed -pd */
3345 XSetICFocus (FRAME_XIC (f
));
3348 XSetInputFocus (event
.xclient
.display
,
3349 event
.xclient
.window
,
3350 RevertToPointerRoot
,
3351 event
.xclient
.data
.l
[1]);
3352 /* Not certain about handling scroll bars here */
3354 else if (event
.xclient
.data
.l
[0]
3355 == dpyinfo
->Xatom_wm_save_yourself
)
3357 /* Save state modify the WM_COMMAND property to
3358 something which can reinstate us. This notifies
3359 the session manager, who's looking for such a
3360 PropertyNotify. Can restart processing when
3361 a keyboard or mouse event arrives. */
3364 f
= x_top_window_to_frame (dpyinfo
,
3365 event
.xclient
.window
);
3367 /* This is just so we only give real data once
3368 for a single Emacs process. */
3369 if (f
== selected_frame
)
3370 XSetCommand (FRAME_X_DISPLAY (f
),
3371 event
.xclient
.window
,
3372 initial_argv
, initial_argc
);
3374 XSetCommand (FRAME_X_DISPLAY (f
),
3375 event
.xclient
.window
,
3379 else if (event
.xclient
.data
.l
[0]
3380 == dpyinfo
->Xatom_wm_delete_window
)
3383 = x_any_window_to_frame (dpyinfo
,
3384 event
.xclient
.window
);
3391 bufp
->kind
= delete_window_event
;
3392 XSETFRAME (bufp
->frame_or_window
, f
);
3400 else if (event
.xclient
.message_type
3401 == dpyinfo
->Xatom_wm_configure_denied
)
3404 else if (event
.xclient
.message_type
3405 == dpyinfo
->Xatom_wm_window_moved
)
3409 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
3411 new_x
= event
.xclient
.data
.s
[0];
3412 new_y
= event
.xclient
.data
.s
[1];
3416 f
->output_data
.x
->left_pos
= new_x
;
3417 f
->output_data
.x
->top_pos
= new_y
;
3421 else if (event
.xclient
.message_type
3422 == dpyinfo
->Xatom_editres
)
3425 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
3426 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
3429 #endif /* HACK_EDITRES */
3433 case SelectionNotify
:
3434 #ifdef USE_X_TOOLKIT
3435 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
3437 #endif /* not USE_X_TOOLKIT */
3438 x_handle_selection_notify (&event
);
3441 case SelectionClear
: /* Someone has grabbed ownership. */
3442 #ifdef USE_X_TOOLKIT
3443 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
3445 #endif /* USE_X_TOOLKIT */
3447 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
3452 bufp
->kind
= selection_clear_event
;
3453 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3454 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3455 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3456 bufp
->frame_or_window
= Qnil
;
3464 case SelectionRequest
: /* Someone wants our selection. */
3465 #ifdef USE_X_TOOLKIT
3466 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
3468 #endif /* USE_X_TOOLKIT */
3469 if (x_queue_selection_requests
)
3470 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
3474 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
3479 bufp
->kind
= selection_request_event
;
3480 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3481 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
3482 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3483 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
3484 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
3485 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3486 bufp
->frame_or_window
= Qnil
;
3494 case PropertyNotify
:
3495 #ifdef USE_X_TOOLKIT
3496 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
3498 #endif /* not USE_X_TOOLKIT */
3499 x_handle_property_notify (&event
);
3502 case ReparentNotify
:
3503 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
3507 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
3508 x_real_positions (f
, &x
, &y
);
3509 f
->output_data
.x
->left_pos
= x
;
3510 f
->output_data
.x
->top_pos
= y
;
3515 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
3518 if (f
->async_visible
== 0)
3520 f
->async_visible
= 1;
3521 f
->async_iconified
= 0;
3522 SET_FRAME_GARBAGED (f
);
3525 dumprectangle (x_window_to_frame (dpyinfo
,
3526 event
.xexpose
.window
),
3527 event
.xexpose
.x
, event
.xexpose
.y
,
3528 event
.xexpose
.width
, event
.xexpose
.height
);
3532 struct scroll_bar
*bar
3533 = x_window_to_scroll_bar (event
.xexpose
.window
);
3536 x_scroll_bar_expose (bar
, &event
);
3537 #ifdef USE_X_TOOLKIT
3540 #endif /* USE_X_TOOLKIT */
3544 case GraphicsExpose
: /* This occurs when an XCopyArea's
3545 source area was obscured or not
3547 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
3551 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
3552 event
.xgraphicsexpose
.width
,
3553 event
.xgraphicsexpose
.height
);
3555 #ifdef USE_X_TOOLKIT
3558 #endif /* USE_X_TOOLKIT */
3561 case NoExpose
: /* This occurs when an XCopyArea's
3562 source area was completely
3567 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
3568 if (f
) /* F may no longer exist if
3569 the frame was deleted. */
3571 /* While a frame is unmapped, display generation is
3572 disabled; you don't want to spend time updating a
3573 display that won't ever be seen. */
3574 f
->async_visible
= 0;
3575 /* We can't distinguish, from the event, whether the window
3576 has become iconified or invisible. So assume, if it
3577 was previously visible, than now it is iconified.
3578 We depend on x_make_frame_invisible to mark it invisible. */
3579 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
3580 f
->async_iconified
= 1;
3582 bufp
->kind
= iconify_event
;
3583 XSETFRAME (bufp
->frame_or_window
, f
);
3591 /* We use x_top_window_to_frame because map events can come
3592 for subwindows and they don't mean that the frame is visible. */
3593 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
3596 f
->async_visible
= 1;
3597 f
->async_iconified
= 0;
3599 /* wait_reading_process_input will notice this and update
3600 the frame's display structures. */
3601 SET_FRAME_GARBAGED (f
);
3605 bufp
->kind
= deiconify_event
;
3606 XSETFRAME (bufp
->frame_or_window
, f
);
3611 else if (! NILP(Vframe_list
)
3612 && ! NILP (XCONS (Vframe_list
)->cdr
))
3613 /* Force a redisplay sooner or later
3614 to update the frame titles
3615 in case this is the second frame. */
3616 record_asynch_buffer_change ();
3620 /* Turn off processing if we become fully obscured. */
3621 case VisibilityNotify
:
3625 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
3629 KeySym keysym
, orig_keysym
;
3630 /* al%imercury@uunet.uu.net says that making this 81 instead of
3631 80 fixed a bug whereby meta chars made his Emacs hang. */
3632 unsigned char copy_buffer
[81];
3635 #if 0 /* This was how we made f10 work in Motif.
3636 The drawback is, you can't type at Emacs when the
3637 the mouse is in the menu bar. So it is better to
3638 turn off f10 in Motif and let Emacs handle it. */
3640 if (lw_window_is_in_menubar (event
.xkey
.window
,
3641 f
->output_data
.x
->menubar_widget
3644 SET_SAVED_KEY_EVENT
;
3647 #endif /* USE_MOTIF */
3651 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
3652 extra_keyboard_modifiers
);
3653 modifiers
= event
.xkey
.state
;
3655 /* This will have to go some day... */
3657 /* make_lispy_event turns chars into control chars.
3658 Don't do it here because XLookupString is too eager. */
3659 event
.xkey
.state
&= ~ControlMask
;
3660 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
3661 | dpyinfo
->super_mod_mask
3662 | dpyinfo
->hyper_mod_mask
3663 | dpyinfo
->alt_mod_mask
);
3668 nbytes
= XmbLookupString (FRAME_XIC (f
),
3669 &event
.xkey
, copy_buffer
,
3674 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
3675 80, &keysym
, &compose_status
);
3677 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
3678 80, &keysym
, &compose_status
);
3681 orig_keysym
= keysym
;
3685 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
3686 || keysym
== XK_Delete
3687 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
3688 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
3690 /* This recognizes the "extended function keys".
3691 It seems there's no cleaner way.
3692 Test IsModifierKey to avoid handling mode_switch
3694 || ((unsigned) (keysym
) >= XK_Select
3695 && (unsigned)(keysym
) < XK_KP_Space
)
3697 #ifdef XK_dead_circumflex
3698 || orig_keysym
== XK_dead_circumflex
3700 #ifdef XK_dead_grave
3701 || orig_keysym
== XK_dead_grave
3703 #ifdef XK_dead_tilde
3704 || orig_keysym
== XK_dead_tilde
3706 #ifdef XK_dead_diaeresis
3707 || orig_keysym
== XK_dead_diaeresis
3709 #ifdef XK_dead_macron
3710 || orig_keysym
== XK_dead_macron
3712 #ifdef XK_dead_degree
3713 || orig_keysym
== XK_dead_degree
3715 #ifdef XK_dead_acute
3716 || orig_keysym
== XK_dead_acute
3718 #ifdef XK_dead_cedilla
3719 || orig_keysym
== XK_dead_cedilla
3721 #ifdef XK_dead_breve
3722 || orig_keysym
== XK_dead_breve
3724 #ifdef XK_dead_ogonek
3725 || orig_keysym
== XK_dead_ogonek
3727 #ifdef XK_dead_caron
3728 || orig_keysym
== XK_dead_caron
3730 #ifdef XK_dead_doubleacute
3731 || orig_keysym
== XK_dead_doubleacute
3733 #ifdef XK_dead_abovedot
3734 || orig_keysym
== XK_dead_abovedot
3736 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
3737 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
3738 /* Any "vendor-specific" key is ok. */
3739 || (orig_keysym
& (1 << 28)))
3740 && ! (IsModifierKey (orig_keysym
)
3742 #ifdef XK_Mode_switch
3743 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
3746 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
3748 #endif /* not HAVE_X11R5 */
3751 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3753 temp_buffer
[temp_index
++] = keysym
;
3754 bufp
->kind
= non_ascii_keystroke
;
3755 bufp
->code
= keysym
;
3756 XSETFRAME (bufp
->frame_or_window
, f
);
3758 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3760 bufp
->timestamp
= event
.xkey
.time
;
3765 else if (numchars
> nbytes
)
3769 for (i
= 0; i
< nbytes
; i
++)
3771 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3773 temp_buffer
[temp_index
++] = copy_buffer
[i
];
3774 bufp
->kind
= ascii_keystroke
;
3775 bufp
->code
= copy_buffer
[i
];
3776 XSETFRAME (bufp
->frame_or_window
, f
);
3778 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3780 bufp
->timestamp
= event
.xkey
.time
;
3795 /* Here's a possible interpretation of the whole
3796 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If you get a
3797 FocusIn event, you have to get a FocusOut event before you
3798 relinquish the focus. If you haven't received a FocusIn event,
3799 then a mere LeaveNotify is enough to free you. */
3802 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
3804 if (event
.xcrossing
.focus
) /* Entered Window */
3806 /* Avoid nasty pop/raise loops. */
3807 if (f
&& (!(f
->auto_raise
)
3809 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
3811 x_new_focus_frame (dpyinfo
, f
);
3812 enter_timestamp
= event
.xcrossing
.time
;
3815 else if (f
== dpyinfo
->x_focus_frame
)
3816 x_new_focus_frame (dpyinfo
, 0);
3817 /* EnterNotify counts as mouse movement,
3818 so update things that depend on mouse position. */
3820 note_mouse_movement (f
, &event
.xmotion
);
3824 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
3825 if (event
.xfocus
.detail
!= NotifyPointer
)
3826 dpyinfo
->x_focus_event_frame
= f
;
3828 x_new_focus_frame (dpyinfo
, f
);
3831 if (f
&& FRAME_XIC (f
))
3832 XSetICFocus (FRAME_XIC (f
));
3838 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
3841 if (f
== dpyinfo
->mouse_face_mouse_frame
)
3842 /* If we move outside the frame,
3843 then we're certainly no longer on any text in the frame. */
3844 clear_mouse_face (dpyinfo
);
3846 if (event
.xcrossing
.focus
)
3847 x_mouse_leave (dpyinfo
);
3850 if (f
== dpyinfo
->x_focus_event_frame
)
3851 dpyinfo
->x_focus_event_frame
= 0;
3852 if (f
== dpyinfo
->x_focus_frame
)
3853 x_new_focus_frame (dpyinfo
, 0);
3859 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
3860 if (event
.xfocus
.detail
!= NotifyPointer
3861 && f
== dpyinfo
->x_focus_event_frame
)
3862 dpyinfo
->x_focus_event_frame
= 0;
3863 if (f
&& f
== dpyinfo
->x_focus_frame
)
3864 x_new_focus_frame (dpyinfo
, 0);
3867 if (f
&& FRAME_XIC (f
))
3868 XUnsetICFocus (FRAME_XIC (f
));
3875 if (dpyinfo
->grabbed
&& last_mouse_frame
3876 && FRAME_LIVE_P (last_mouse_frame
))
3877 f
= last_mouse_frame
;
3879 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
3881 note_mouse_movement (f
, &event
.xmotion
);
3884 struct scroll_bar
*bar
3885 = x_window_to_scroll_bar (event
.xmotion
.window
);
3888 x_scroll_bar_note_movement (bar
, &event
);
3890 /* If we move outside the frame,
3891 then we're certainly no longer on any text in the frame. */
3892 clear_mouse_face (dpyinfo
);
3897 case ConfigureNotify
:
3898 f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
3900 #ifdef USE_X_TOOLKIT
3901 && (event
.xconfigure
.window
== XtWindow (f
->output_data
.x
->widget
))
3905 #ifndef USE_X_TOOLKIT
3906 /* In the toolkit version, change_frame_size
3907 is called by the code that handles resizing
3908 of the EmacsFrame widget. */
3910 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
3911 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
3913 /* Even if the number of character rows and columns has
3914 not changed, the font size may have changed, so we need
3915 to check the pixel dimensions as well. */
3916 if (columns
!= f
->width
3917 || rows
!= f
->height
3918 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
3919 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
3921 change_frame_size (f
, rows
, columns
, 0, 1);
3922 SET_FRAME_GARBAGED (f
);
3926 /* Formerly, in the USE_X_TOOLKIT version,
3927 we did not test send_event here. */
3929 #ifndef USE_X_TOOLKIT
3930 && ! event
.xconfigure
.send_event
3937 /* Find the position of the outside upper-left corner of
3938 the window, in the root coordinate system. Don't
3939 refer to the parent window here; we may be processing
3940 this event after the window manager has changed our
3941 parent, but before we have reached the ReparentNotify. */
3942 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3944 /* From-window, to-window. */
3945 event
.xconfigure
.window
,
3946 FRAME_X_DISPLAY_INFO (f
)->root_window
,
3948 /* From-position, to-position. */
3949 -event
.xconfigure
.border_width
,
3950 -event
.xconfigure
.border_width
,
3955 event
.xconfigure
.x
= win_x
;
3956 event
.xconfigure
.y
= win_y
;
3959 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
3960 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
3961 f
->output_data
.x
->left_pos
= event
.xconfigure
.x
;
3962 f
->output_data
.x
->top_pos
= event
.xconfigure
.y
;
3964 /* What we have now is the position of Emacs's own window.
3965 Convert that to the position of the window manager window. */
3968 x_real_positions (f
, &x
, &y
);
3969 f
->output_data
.x
->left_pos
= x
;
3970 f
->output_data
.x
->top_pos
= y
;
3971 /* Formerly we did not do this in the USE_X_TOOLKIT
3972 version. Let's try making them the same. */
3973 /* #ifndef USE_X_TOOLKIT */
3974 if (y
!= event
.xconfigure
.y
)
3976 /* Since the WM decorations come below top_pos now,
3977 we must put them below top_pos in the future. */
3978 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
3979 x_wm_set_size_hint (f
, (long) 0, 0);
3989 /* If we decide we want to generate an event to be seen
3990 by the rest of Emacs, we put it here. */
3991 struct input_event emacs_event
;
3992 emacs_event
.kind
= no_event
;
3994 bzero (&compose_status
, sizeof (compose_status
));
3996 if (dpyinfo
->grabbed
&& last_mouse_frame
3997 && FRAME_LIVE_P (last_mouse_frame
))
3998 f
= last_mouse_frame
;
4000 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
4004 if (!dpyinfo
->x_focus_frame
|| f
== dpyinfo
->x_focus_frame
)
4005 construct_mouse_click (&emacs_event
, &event
, f
);
4009 struct scroll_bar
*bar
4010 = x_window_to_scroll_bar (event
.xbutton
.window
);
4013 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
4016 if (event
.type
== ButtonPress
)
4018 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
4019 last_mouse_frame
= f
;
4023 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
4026 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
4028 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
4034 #ifdef USE_X_TOOLKIT
4035 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
4036 /* For a down-event in the menu bar,
4037 don't pass it to Xt right now.
4038 Instead, save it away
4039 and we will pass it to Xt from kbd_buffer_get_event.
4040 That way, we can run some Lisp code first. */
4041 if (f
&& event
.type
== ButtonPress
4042 /* Verify the event is really within the menu bar
4043 and not just sent to it due to grabbing. */
4044 && event
.xbutton
.x
>= 0
4045 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
4046 && event
.xbutton
.y
>= 0
4047 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
4048 && event
.xbutton
.same_screen
)
4050 SET_SAVED_BUTTON_EVENT
;
4051 XSETFRAME (last_mouse_press_frame
, f
);
4053 else if (event
.type
== ButtonPress
)
4055 last_mouse_press_frame
= Qnil
;
4058 #ifdef USE_MOTIF /* This should do not harm for Lucid,
4059 but I am trying to be cautious. */
4060 else if (event
.type
== ButtonRelease
)
4062 if (!NILP (last_mouse_press_frame
))
4064 f
= XFRAME (last_mouse_press_frame
);
4065 if (f
->output_data
.x
)
4067 SET_SAVED_BUTTON_EVENT
;
4073 #endif /* USE_MOTIF */
4076 #endif /* USE_X_TOOLKIT */
4080 case CirculateNotify
:
4082 case CirculateRequest
:
4086 /* Someone has changed the keyboard mapping - update the
4088 switch (event
.xmapping
.request
)
4090 case MappingModifier
:
4091 x_find_modifier_meanings (dpyinfo
);
4092 /* This is meant to fall through. */
4093 case MappingKeyboard
:
4094 XRefreshKeyboardMapping (&event
.xmapping
);
4100 #ifdef USE_X_TOOLKIT
4102 XtDispatchEvent (&event
);
4104 #endif /* USE_X_TOOLKIT */
4110 /* On some systems, an X bug causes Emacs to get no more events
4111 when the window is destroyed. Detect that. (1994.) */
4114 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
4115 One XNOOP in 100 loops will make Emacs terminate.
4116 B. Bretthauer, 1994 */
4118 if (x_noop_count
>= 100)
4122 if (next_noop_dpyinfo
== 0)
4123 next_noop_dpyinfo
= x_display_list
;
4125 XNoOp (next_noop_dpyinfo
->display
);
4127 /* Each time we get here, cycle through the displays now open. */
4128 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
4132 /* If the focus was just given to an autoraising frame,
4134 /* ??? This ought to be able to handle more than one such frame. */
4135 if (pending_autoraise_frame
)
4137 x_raise_frame (pending_autoraise_frame
);
4138 pending_autoraise_frame
= 0;
4145 /* Drawing the cursor. */
4148 /* Draw a hollow box cursor on frame F at X, Y.
4149 Don't change the inside of the box. */
4152 x_draw_box (f
, x
, y
)
4156 int left
= CHAR_TO_PIXEL_COL (f
, x
);
4157 int top
= CHAR_TO_PIXEL_ROW (f
, y
);
4158 int width
= FONT_WIDTH (f
->output_data
.x
->font
);
4159 int height
= f
->output_data
.x
->line_height
;
4161 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4162 f
->output_data
.x
->cursor_gc
,
4163 left
, top
, width
- 1, height
- 1);
4166 /* Clear the cursor of frame F to background color,
4167 and mark the cursor as not shown.
4168 This is used when the text where the cursor is
4169 is about to be rewritten. */
4177 if (! FRAME_VISIBLE_P (f
)
4178 || f
->phys_cursor_x
< 0)
4181 x_update_cursor (f
, 0);
4182 f
->phys_cursor_x
= -1;
4185 /* Redraw the glyph at ROW, COLUMN on frame F, in the style
4186 HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
4190 x_draw_single_glyph (f
, row
, column
, glyph
, highlight
)
4197 CHAR_TO_PIXEL_COL (f
, column
),
4198 CHAR_TO_PIXEL_ROW (f
, row
),
4199 &glyph
, 1, highlight
, 0);
4203 x_display_bar_cursor (f
, on
, x
, y
)
4208 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4210 /* This is pointless on invisible frames, and dangerous on garbaged
4211 frames; in the latter case, the frame may be in the midst of
4212 changing its size, and x and y may be off the frame. */
4213 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4216 if (! on
&& f
->phys_cursor_x
< 0)
4219 /* If there is anything wrong with the current cursor state, remove it. */
4220 if (f
->phys_cursor_x
>= 0
4222 || f
->phys_cursor_x
!= x
4223 || f
->phys_cursor_y
!= y
4224 || f
->output_data
.x
->current_cursor
!= bar_cursor
))
4226 /* Erase the cursor by redrawing the character underneath it. */
4227 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4228 f
->phys_cursor_glyph
,
4229 current_glyphs
->highlight
[f
->phys_cursor_y
]);
4230 f
->phys_cursor_x
= -1;
4233 /* If we now need a cursor in the new place or in the new form, do it so. */
4235 && (f
->phys_cursor_x
< 0
4236 || (f
->output_data
.x
->current_cursor
!= bar_cursor
)))
4238 f
->phys_cursor_glyph
4239 = ((current_glyphs
->enable
[y
]
4240 && x
< current_glyphs
->used
[y
])
4241 ? current_glyphs
->glyphs
[y
][x
]
4243 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4244 f
->output_data
.x
->cursor_gc
,
4245 CHAR_TO_PIXEL_COL (f
, x
),
4246 CHAR_TO_PIXEL_ROW (f
, y
),
4247 max (f
->output_data
.x
->cursor_width
, 1),
4248 f
->output_data
.x
->line_height
);
4250 f
->phys_cursor_x
= x
;
4251 f
->phys_cursor_y
= y
;
4253 f
->output_data
.x
->current_cursor
= bar_cursor
;
4256 if (updating_frame
!= f
)
4257 XFlush (FRAME_X_DISPLAY (f
));
4261 /* Turn the displayed cursor of frame F on or off according to ON.
4262 If ON is nonzero, where to put the cursor is specified by X and Y. */
4265 x_display_box_cursor (f
, on
, x
, y
)
4270 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4272 /* This is pointless on invisible frames, and dangerous on garbaged
4273 frames; in the latter case, the frame may be in the midst of
4274 changing its size, and x and y may be off the frame. */
4275 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4278 /* If cursor is off and we want it off, return quickly. */
4279 if (!on
&& f
->phys_cursor_x
< 0)
4282 /* If cursor is currently being shown and we don't want it to be
4283 or it is in the wrong place,
4284 or we want a hollow box and it's not so, (pout!)
4286 if (f
->phys_cursor_x
>= 0
4288 || f
->phys_cursor_x
!= x
4289 || f
->phys_cursor_y
!= y
4290 || (f
->output_data
.x
->current_cursor
!= hollow_box_cursor
4291 && (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
))))
4293 int mouse_face_here
= 0;
4294 struct frame_glyphs
*active_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4296 /* If the cursor is in the mouse face area, redisplay that when
4297 we clear the cursor. */
4298 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
4300 (f
->phys_cursor_y
> FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
4301 || (f
->phys_cursor_y
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
4302 && f
->phys_cursor_x
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
))
4304 (f
->phys_cursor_y
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
4305 || (f
->phys_cursor_y
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
4306 && f
->phys_cursor_x
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
))
4307 /* Don't redraw the cursor's spot in mouse face
4308 if it is at the end of a line (on a newline).
4309 The cursor appears there, but mouse highlighting does not. */
4310 && active_glyphs
->used
[f
->phys_cursor_y
] > f
->phys_cursor_x
)
4311 mouse_face_here
= 1;
4313 /* If the font is not as tall as a whole line,
4314 we must explicitly clear the line's whole height. */
4315 if (FONT_HEIGHT (f
->output_data
.x
->font
) != f
->output_data
.x
->line_height
)
4316 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4317 CHAR_TO_PIXEL_COL (f
, f
->phys_cursor_x
),
4318 CHAR_TO_PIXEL_ROW (f
, f
->phys_cursor_y
),
4319 FONT_WIDTH (f
->output_data
.x
->font
),
4320 f
->output_data
.x
->line_height
, False
);
4321 /* Erase the cursor by redrawing the character underneath it. */
4322 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4323 f
->phys_cursor_glyph
,
4326 : current_glyphs
->highlight
[f
->phys_cursor_y
]));
4327 f
->phys_cursor_x
= -1;
4330 /* If we want to show a cursor,
4331 or we want a box cursor and it's not so,
4332 write it in the right place. */
4334 && (f
->phys_cursor_x
< 0
4335 || (f
->output_data
.x
->current_cursor
!= filled_box_cursor
4336 && f
== FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)))
4338 f
->phys_cursor_glyph
4339 = ((current_glyphs
->enable
[y
]
4340 && x
< current_glyphs
->used
[y
])
4341 ? current_glyphs
->glyphs
[y
][x
]
4343 if (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
4345 x_draw_box (f
, x
, y
);
4346 f
->output_data
.x
->current_cursor
= hollow_box_cursor
;
4350 x_draw_single_glyph (f
, y
, x
,
4351 f
->phys_cursor_glyph
, 2);
4352 f
->output_data
.x
->current_cursor
= filled_box_cursor
;
4355 f
->phys_cursor_x
= x
;
4356 f
->phys_cursor_y
= y
;
4359 if (updating_frame
!= f
)
4360 XFlush (FRAME_X_DISPLAY (f
));
4363 /* Display the cursor on frame F, or clear it, according to ON.
4364 Also set the frame's cursor position to X and Y. */
4366 x_display_cursor (f
, on
, x
, y
)
4373 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4374 x_display_box_cursor (f
, on
, x
, y
);
4375 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4376 x_display_bar_cursor (f
, on
, x
, y
);
4378 /* Those are the only two we have implemented! */
4384 /* Display the cursor on frame F, or clear it, according to ON.
4385 Don't change the cursor's position. */
4387 x_update_cursor (f
, on
)
4391 /* If we don't have any previous cursor position to use,
4392 leave the cursor off. */
4393 if (f
->phys_cursor_x
< 0)
4398 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4399 x_display_box_cursor (f
, on
, f
->phys_cursor_x
, f
->phys_cursor_y
);
4400 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4401 x_display_bar_cursor (f
, on
, f
->phys_cursor_x
, f
->phys_cursor_y
);
4403 /* Those are the only two we have implemented! */
4411 /* Refresh bitmap kitchen sink icon for frame F
4412 when we get an expose event for it. */
4417 /* Normally, the window manager handles this function. */
4420 /* Make the x-window of frame F use the gnu icon bitmap. */
4423 x_bitmap_icon (f
, file
)
4427 int mask
, bitmap_id
;
4430 if (FRAME_X_WINDOW (f
) == 0)
4433 /* Free up our existing icon bitmap if any. */
4434 if (f
->output_data
.x
->icon_bitmap
> 0)
4435 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
4436 f
->output_data
.x
->icon_bitmap
= 0;
4439 bitmap_id
= x_create_bitmap_from_file (f
, file
);
4442 /* Create the GNU bitmap if necessary. */
4443 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
4444 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
4445 = x_create_bitmap_from_data (f
, gnu_bits
,
4446 gnu_width
, gnu_height
);
4448 /* The first time we create the GNU bitmap,
4449 this increments the refcount one extra time.
4450 As a result, the GNU bitmap is never freed.
4451 That way, we don't have to worry about allocating it again. */
4452 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
4454 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
4457 x_wm_set_icon_pixmap (f
, bitmap_id
);
4458 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
4464 /* Make the x-window of frame F use a rectangle with text.
4465 Use ICON_NAME as the text. */
4468 x_text_icon (f
, icon_name
)
4472 if (FRAME_X_WINDOW (f
) == 0)
4478 text
.value
= (unsigned char *) icon_name
;
4479 text
.encoding
= XA_STRING
;
4481 text
.nitems
= strlen (icon_name
);
4482 #ifdef USE_X_TOOLKIT
4483 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
4485 #else /* not USE_X_TOOLKIT */
4486 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
4487 #endif /* not USE_X_TOOLKIT */
4489 #else /* not HAVE_X11R4 */
4490 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
4491 #endif /* not HAVE_X11R4 */
4493 if (f
->output_data
.x
->icon_bitmap
> 0)
4494 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
4495 f
->output_data
.x
->icon_bitmap
= 0;
4496 x_wm_set_icon_pixmap (f
, 0);
4501 /* Handling X errors. */
4503 /* Handle the loss of connection to display DISPLAY. */
4506 x_connection_closed (display
, error_message
)
4508 char *error_message
;
4510 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
4511 Lisp_Object frame
, tail
;
4513 /* Indicate that this display is dead. */
4515 #ifdef USE_X_TOOLKIT
4516 XtCloseDisplay (display
);
4519 dpyinfo
->display
= 0;
4521 /* First delete frames whose minibuffers are on frames
4522 that are on the dead display. */
4523 FOR_EACH_FRAME (tail
, frame
)
4525 Lisp_Object minibuf_frame
;
4527 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
4528 if (FRAME_X_P (XFRAME (frame
))
4529 && FRAME_X_P (XFRAME (minibuf_frame
))
4530 && ! EQ (frame
, minibuf_frame
)
4531 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
4532 Fdelete_frame (frame
, Qt
);
4535 /* Now delete all remaining frames on the dead display.
4536 We are now sure none of these is used as the minibuffer
4537 for another frame that we need to delete. */
4538 FOR_EACH_FRAME (tail
, frame
)
4539 if (FRAME_X_P (XFRAME (frame
))
4540 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
4542 /* Set this to t so that Fdelete_frame won't get confused
4543 trying to find a replacement. */
4544 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
4545 Fdelete_frame (frame
, Qt
);
4549 x_delete_display (dpyinfo
);
4551 if (x_display_list
== 0)
4553 fprintf (stderr
, "%s\n", error_message
);
4554 shut_down_emacs (0, 0, Qnil
);
4558 /* Ordinary stack unwind doesn't deal with these. */
4560 sigunblock (sigmask (SIGIO
));
4562 sigunblock (sigmask (SIGALRM
));
4563 TOTALLY_UNBLOCK_INPUT
;
4565 clear_waiting_for_input ();
4566 error ("%s", error_message
);
4569 /* This is the usual handler for X protocol errors.
4570 It kills all frames on the display that we got the error for.
4571 If that was the only one, it prints an error message and kills Emacs. */
4574 x_error_quitter (display
, error
)
4578 char buf
[256], buf1
[356];
4580 /* Note that there is no real way portable across R3/R4 to get the
4581 original error handler. */
4583 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
4584 sprintf (buf1
, "X protocol error: %s on protocol request %d",
4585 buf
, error
->request_code
);
4586 x_connection_closed (display
, buf1
);
4589 /* This is the handler for X IO errors, always.
4590 It kills all frames on the display that we lost touch with.
4591 If that was the only one, it prints an error message and kills Emacs. */
4594 x_io_error_quitter (display
)
4599 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
4600 x_connection_closed (display
, buf
);
4603 /* Handle SIGPIPE, which can happen when the connection to a server
4604 simply goes away. SIGPIPE is handled by x_connection_signal.
4605 Don't need to do anything, because the write which caused the
4606 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
4607 which will do the appropriate cleanup for us. */
4610 x_connection_signal (signalnum
) /* If we don't have an argument, */
4611 int signalnum
; /* some compilers complain in signal calls. */
4614 /* USG systems forget handlers when they are used;
4615 must reestablish each time */
4616 signal (signalnum
, x_connection_signal
);
4620 /* A buffer for storing X error messages. */
4621 static char *x_caught_error_message
;
4622 #define X_CAUGHT_ERROR_MESSAGE_SIZE 200
4624 /* An X error handler which stores the error message in
4625 x_caught_error_message. This is what's installed when
4626 x_catch_errors is in effect. */
4629 x_error_catcher (display
, error
)
4633 XGetErrorText (display
, error
->error_code
,
4634 x_caught_error_message
, X_CAUGHT_ERROR_MESSAGE_SIZE
);
4638 /* Begin trapping X errors for display DPY. Actually we trap X errors
4639 for all displays, but DPY should be the display you are actually
4642 After calling this function, X protocol errors no longer cause
4643 Emacs to exit; instead, they are recorded in x_cfc_error_message.
4645 Calling x_check_errors signals an Emacs error if an X error has
4646 occurred since the last call to x_catch_errors or x_check_errors.
4648 Calling x_uncatch_errors resumes the normal error handling. */
4650 void x_catch_errors (), x_check_errors (), x_uncatch_errors ();
4653 x_catch_errors (dpy
)
4656 /* Make sure any errors from previous requests have been dealt with. */
4659 /* Set up the error buffer. */
4660 x_caught_error_message
4661 = (char*) xmalloc (X_CAUGHT_ERROR_MESSAGE_SIZE
);
4662 x_caught_error_message
[0] = '\0';
4664 /* Install our little error handler. */
4665 XSetErrorHandler (x_error_catcher
);
4668 /* If any X protocol errors have arrived since the last call to
4669 x_catch_errors or x_check_errors, signal an Emacs error using
4670 sprintf (a buffer, FORMAT, the x error message text) as the text. */
4673 x_check_errors (dpy
, format
)
4677 /* Make sure to catch any errors incurred so far. */
4680 if (x_caught_error_message
[0])
4682 char buf
[X_CAUGHT_ERROR_MESSAGE_SIZE
+ 56];
4684 sprintf (buf
, format
, x_caught_error_message
);
4685 x_uncatch_errors (dpy
);
4690 /* Nonzero if we had any X protocol errors since we did x_catch_errors. */
4693 x_had_errors_p (dpy
)
4696 /* Make sure to catch any errors incurred so far. */
4699 return x_caught_error_message
[0] != 0;
4702 /* Stop catching X protocol errors and let them make Emacs die. */
4705 x_uncatch_errors (dpy
)
4708 xfree (x_caught_error_message
);
4709 x_caught_error_message
= 0;
4710 XSetErrorHandler (x_error_quitter
);
4714 static unsigned int x_wire_count
;
4717 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
4722 /* Changing the font of the frame. */
4724 /* Give frame F the font named FONTNAME as its default font, and
4725 return the full name of that font. FONTNAME may be a wildcard
4726 pattern; in that case, we choose some font that fits the pattern.
4727 The return value shows which font we chose. */
4730 x_new_font (f
, fontname
)
4732 register char *fontname
;
4735 int n_matching_fonts
;
4736 XFontStruct
*font_info
;
4739 /* Get a list of all the fonts that match this name. Once we
4740 have a list of matching fonts, we compare them against the fonts
4741 we already have by comparing font ids. */
4742 font_names
= (char **) XListFonts (FRAME_X_DISPLAY (f
), fontname
,
4743 1024, &n_matching_fonts
);
4744 /* Apparently it doesn't set n_matching_fonts to zero when it can't
4745 find any matches; font_names == 0 is the only clue. */
4747 n_matching_fonts
= 0;
4749 /* Don't just give up if n_matching_fonts is 0.
4750 Apparently there's a bug on Suns: XListFontsWithInfo can
4751 fail to find a font, but XLoadQueryFont may still find it. */
4753 /* See if we've already loaded a matching font. */
4754 already_loaded
= -1;
4755 if (n_matching_fonts
!= 0)
4759 for (i
= 0; i
< FRAME_X_DISPLAY_INFO (f
)->n_fonts
; i
++)
4760 for (j
= 0; j
< n_matching_fonts
; j
++)
4761 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].name
, font_names
[j
])
4762 || !strcmp (FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].full_name
, font_names
[j
]))
4765 fontname
= FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].full_name
;
4771 /* If we have, just return it from the table. */
4772 if (already_loaded
>= 0)
4773 f
->output_data
.x
->font
= FRAME_X_DISPLAY_INFO (f
)->font_table
[already_loaded
].font
;
4774 /* Otherwise, load the font and add it to the table. */
4782 /* Try to find a character-cell font in the list. */
4784 /* A laudable goal, but this isn't how to do it. */
4785 for (i
= 0; i
< n_matching_fonts
; i
++)
4786 if (! font_info
[i
].per_char
)
4792 /* See comment above. */
4793 if (n_matching_fonts
!= 0)
4794 fontname
= font_names
[i
];
4796 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
4799 /* Free the information from XListFonts. */
4800 if (n_matching_fonts
)
4801 XFreeFontNames (font_names
);
4805 /* Do we need to create the table? */
4806 if (FRAME_X_DISPLAY_INFO (f
)->font_table_size
== 0)
4808 FRAME_X_DISPLAY_INFO (f
)->font_table_size
= 16;
4809 FRAME_X_DISPLAY_INFO (f
)->font_table
4810 = (struct font_info
*) xmalloc (FRAME_X_DISPLAY_INFO (f
)->font_table_size
4811 * sizeof (struct font_info
));
4813 /* Do we need to grow the table? */
4814 else if (FRAME_X_DISPLAY_INFO (f
)->n_fonts
4815 >= FRAME_X_DISPLAY_INFO (f
)->font_table_size
)
4817 FRAME_X_DISPLAY_INFO (f
)->font_table_size
*= 2;
4818 FRAME_X_DISPLAY_INFO (f
)->font_table
4819 = (struct font_info
*) xrealloc (FRAME_X_DISPLAY_INFO (f
)->font_table
,
4820 (FRAME_X_DISPLAY_INFO (f
)->font_table_size
4821 * sizeof (struct font_info
)));
4824 /* Try to get the full name of FONT. Put it in full_name. */
4826 for (i
= 0; i
< font
->n_properties
; i
++)
4828 if (FRAME_X_DISPLAY_INFO (f
)->Xatom_FONT
== font
->properties
[i
].name
)
4830 char *name
= XGetAtomName (FRAME_X_DISPLAY (f
),
4831 (Atom
) (font
->properties
[i
].card32
));
4835 /* Count the number of dashes in the "full name".
4836 If it is too few, this isn't really the font's full name,
4838 In X11R4, the fonts did not come with their canonical names
4854 n_fonts
= FRAME_X_DISPLAY_INFO (f
)->n_fonts
;
4855 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
= (char *) xmalloc (strlen (fontname
) + 1);
4856 bcopy (fontname
, FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
, strlen (fontname
) + 1);
4858 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].full_name
= full_name
;
4860 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].full_name
= FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
;
4861 f
->output_data
.x
->font
= FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].font
= font
;
4862 FRAME_X_DISPLAY_INFO (f
)->n_fonts
++;
4865 fontname
= full_name
;
4868 /* Compute the scroll bar width in character columns. */
4869 if (f
->scroll_bar_pixel_width
> 0)
4871 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
4872 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
4875 f
->scroll_bar_cols
= 2;
4877 /* Now make the frame display the given font. */
4878 if (FRAME_X_WINDOW (f
) != 0)
4880 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
4881 f
->output_data
.x
->font
->fid
);
4882 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
4883 f
->output_data
.x
->font
->fid
);
4884 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
4885 f
->output_data
.x
->font
->fid
);
4887 frame_update_line_height (f
);
4888 x_set_window_size (f
, 0, f
->width
, f
->height
);
4891 /* If we are setting a new frame's font for the first time,
4892 there are no faces yet, so this font's height is the line height. */
4893 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
4896 Lisp_Object lispy_name
;
4898 lispy_name
= build_string (fontname
);
4900 /* Free the information from XListFonts. The data
4901 we actually retain comes from XLoadQueryFont. */
4902 XFreeFontNames (font_names
);
4908 /* Calculate the absolute position in frame F
4909 from its current recorded position values and gravity. */
4911 x_calc_absolute_position (f
)
4915 int win_x
= 0, win_y
= 0;
4916 int flags
= f
->output_data
.x
->size_hint_flags
;
4919 #ifdef USE_X_TOOLKIT
4920 this_window
= XtWindow (f
->output_data
.x
->widget
);
4922 this_window
= FRAME_X_WINDOW (f
);
4925 /* Find the position of the outside upper-left corner of
4926 the inner window, with respect to the outer window. */
4927 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
4930 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
4932 /* From-window, to-window. */
4934 f
->output_data
.x
->parent_desc
,
4936 /* From-position, to-position. */
4937 0, 0, &win_x
, &win_y
,
4944 /* Treat negative positions as relative to the leftmost bottommost
4945 position that fits on the screen. */
4946 if (flags
& XNegative
)
4947 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
4948 - 2 * f
->output_data
.x
->border_width
- win_x
4950 + f
->output_data
.x
->left_pos
);
4952 if (flags
& YNegative
)
4953 /* We used to subtract f->output_data.x->menubar_height here
4954 in the toolkit case, but PIXEL_HEIGHT already includes that. */
4955 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
4956 - 2 * f
->output_data
.x
->border_width
- win_y
4958 + f
->output_data
.x
->top_pos
);
4960 /* The left_pos and top_pos
4961 are now relative to the top and left screen edges,
4962 so the flags should correspond. */
4963 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
4966 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
4967 to really change the position, and 0 when calling from
4968 x_make_frame_visible (in that case, XOFF and YOFF are the current
4969 position values). It is -1 when calling from x_set_frame_parameters,
4970 which means, do adjust for borders but don't change the gravity. */
4972 x_set_offset (f
, xoff
, yoff
, change_gravity
)
4974 register int xoff
, yoff
;
4977 int modified_top
, modified_left
;
4979 if (change_gravity
> 0)
4981 f
->output_data
.x
->top_pos
= yoff
;
4982 f
->output_data
.x
->left_pos
= xoff
;
4983 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
4985 f
->output_data
.x
->size_hint_flags
|= XNegative
;
4987 f
->output_data
.x
->size_hint_flags
|= YNegative
;
4988 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
4990 x_calc_absolute_position (f
);
4993 x_wm_set_size_hint (f
, (long) 0, 0);
4995 /* It is a mystery why we need to add the border_width here
4996 when the frame is already visible, but experiment says we do. */
4997 modified_left
= f
->output_data
.x
->left_pos
;
4998 modified_top
= f
->output_data
.x
->top_pos
;
4999 if (change_gravity
!= 0)
5001 modified_left
+= f
->output_data
.x
->border_width
;
5002 modified_top
+= f
->output_data
.x
->border_width
;
5005 #ifdef USE_X_TOOLKIT
5006 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
5007 modified_left
, modified_top
);
5008 #else /* not USE_X_TOOLKIT */
5009 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5010 modified_left
, modified_top
);
5011 #endif /* not USE_X_TOOLKIT */
5015 /* Call this to change the size of frame F's x-window.
5016 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5017 for this size change and subsequent size changes.
5018 Otherwise we leave the window gravity unchanged. */
5020 x_set_window_size (f
, change_gravity
, cols
, rows
)
5025 int pixelwidth
, pixelheight
;
5028 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5032 #ifdef USE_X_TOOLKIT
5034 /* The x and y position of the widget is clobbered by the
5035 call to XtSetValues within EmacsFrameSetCharSize.
5036 This is a real kludge, but I don't understand Xt so I can't
5037 figure out a correct fix. Can anyone else tell me? -- rms. */
5038 int xpos
= f
->output_data
.x
->widget
->core
.x
;
5039 int ypos
= f
->output_data
.x
->widget
->core
.y
;
5040 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
5041 f
->output_data
.x
->widget
->core
.x
= xpos
;
5042 f
->output_data
.x
->widget
->core
.y
= ypos
;
5045 #else /* not USE_X_TOOLKIT */
5047 check_frame_size (f
, &rows
, &cols
);
5048 f
->output_data
.x
->vertical_scroll_bar_extra
5049 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5051 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
5052 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
5053 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
5054 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
5055 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
5057 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
5058 x_wm_set_size_hint (f
, (long) 0, 0);
5060 XSync (FRAME_X_DISPLAY (f
), False
);
5061 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5062 pixelwidth
, pixelheight
);
5064 /* Now, strictly speaking, we can't be sure that this is accurate,
5065 but the window manager will get around to dealing with the size
5066 change request eventually, and we'll hear how it went when the
5067 ConfigureNotify event gets here.
5069 We could just not bother storing any of this information here,
5070 and let the ConfigureNotify event set everything up, but that
5071 might be kind of confusing to the lisp code, since size changes
5072 wouldn't be reported in the frame parameters until some random
5073 point in the future when the ConfigureNotify event arrives. */
5074 change_frame_size (f
, rows
, cols
, 0, 0);
5075 PIXEL_WIDTH (f
) = pixelwidth
;
5076 PIXEL_HEIGHT (f
) = pixelheight
;
5078 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5079 receive in the ConfigureNotify event; if we get what we asked
5080 for, then the event won't cause the screen to become garbaged, so
5081 we have to make sure to do it here. */
5082 SET_FRAME_GARBAGED (f
);
5084 XFlush (FRAME_X_DISPLAY (f
));
5086 #endif /* not USE_X_TOOLKIT */
5088 /* If cursor was outside the new size, mark it as off. */
5089 if (f
->phys_cursor_y
>= rows
5090 || f
->phys_cursor_x
>= cols
)
5092 f
->phys_cursor_x
= -1;
5093 f
->phys_cursor_y
= -1;
5096 /* Clear out any recollection of where the mouse highlighting was,
5097 since it might be in a place that's outside the new frame size.
5098 Actually checking whether it is outside is a pain in the neck,
5099 so don't try--just let the highlighting be done afresh with new size. */
5100 window
= dpyinfo
->mouse_face_window
;
5101 if (! NILP (window
) && XFRAME (window
) == f
)
5103 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
5104 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
5105 dpyinfo
->mouse_face_window
= Qnil
;
5111 /* Mouse warping. */
5114 x_set_mouse_position (f
, x
, y
)
5120 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
5121 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
5123 if (pix_x
< 0) pix_x
= 0;
5124 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
5126 if (pix_y
< 0) pix_y
= 0;
5127 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
5131 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
5132 0, 0, 0, 0, pix_x
, pix_y
);
5136 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
5139 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
5145 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
5146 0, 0, 0, 0, pix_x
, pix_y
);
5150 /* focus shifting, raising and lowering. */
5152 x_focus_on_frame (f
)
5155 #if 0 /* This proves to be unpleasant. */
5159 /* I don't think that the ICCCM allows programs to do things like this
5160 without the interaction of the window manager. Whatever you end up
5161 doing with this code, do it to x_unfocus_frame too. */
5162 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5163 RevertToPointerRoot
, CurrentTime
);
5171 /* Look at the remarks in x_focus_on_frame. */
5172 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
5173 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
5174 RevertToPointerRoot
, CurrentTime
);
5178 /* Raise frame F. */
5183 if (f
->async_visible
)
5186 #ifdef USE_X_TOOLKIT
5187 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
5188 #else /* not USE_X_TOOLKIT */
5189 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5190 #endif /* not USE_X_TOOLKIT */
5191 XFlush (FRAME_X_DISPLAY (f
));
5196 /* Lower frame F. */
5201 if (f
->async_visible
)
5204 #ifdef USE_X_TOOLKIT
5205 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
5206 #else /* not USE_X_TOOLKIT */
5207 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5208 #endif /* not USE_X_TOOLKIT */
5209 XFlush (FRAME_X_DISPLAY (f
));
5215 XTframe_raise_lower (f
, raise_flag
)
5225 /* Change of visibility. */
5227 /* This tries to wait until the frame is really visible.
5228 However, if the window manager asks the user where to position
5229 the frame, this will return before the user finishes doing that.
5230 The frame will not actually be visible at that time,
5231 but it will become visible later when the window manager
5232 finishes with it. */
5234 x_make_frame_visible (f
)
5242 type
= x_icon_type (f
);
5244 x_bitmap_icon (f
, type
);
5246 if (! FRAME_VISIBLE_P (f
))
5248 /* We test FRAME_GARBAGED_P here to make sure we don't
5249 call x_set_offset a second time
5250 if we get to x_make_frame_visible a second time
5251 before the window gets really visible. */
5252 if (! FRAME_ICONIFIED_P (f
)
5253 && ! f
->output_data
.x
->asked_for_visible
)
5254 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
5256 f
->output_data
.x
->asked_for_visible
= 1;
5258 if (! EQ (Vx_no_window_manager
, Qt
))
5259 x_wm_set_window_state (f
, NormalState
);
5260 #ifdef USE_X_TOOLKIT
5261 /* This was XtPopup, but that did nothing for an iconified frame. */
5262 XtMapWidget (f
->output_data
.x
->widget
);
5263 #else /* not USE_X_TOOLKIT */
5264 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5265 #endif /* not USE_X_TOOLKIT */
5266 #if 0 /* This seems to bring back scroll bars in the wrong places
5267 if the window configuration has changed. They seem
5268 to come back ok without this. */
5269 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5270 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5274 XFlush (FRAME_X_DISPLAY (f
));
5276 /* Synchronize to ensure Emacs knows the frame is visible
5277 before we do anything else. We do this loop with input not blocked
5278 so that incoming events are handled. */
5281 int count
= input_signal_count
;
5283 /* This must come after we set COUNT. */
5286 XSETFRAME (frame
, f
);
5291 /* Once we have handled input events,
5292 we should have received the MapNotify if one is coming.
5293 So if we have not got it yet, stop looping.
5294 Some window managers make their own decisions
5295 about visibility. */
5296 if (input_signal_count
!= count
)
5298 /* Machines that do polling rather than SIGIO have been observed
5299 to go into a busy-wait here. So we'll fake an alarm signal
5300 to let the handler know that there's something to be read.
5301 We used to raise a real alarm, but it seems that the handler
5302 isn't always enabled here. This is probably a bug. */
5303 if (input_polling_used ())
5305 /* It could be confusing if a real alarm arrives while processing
5306 the fake one. Turn it off and let the handler reset it. */
5308 input_poll_signal ();
5310 /* Once we have handled input events,
5311 we should have received the MapNotify if one is coming.
5312 So if we have not got it yet, stop looping.
5313 Some window managers make their own decisions
5314 about visibility. */
5315 if (input_signal_count
!= count
)
5318 FRAME_SAMPLE_VISIBILITY (f
);
5322 /* Change from mapped state to withdrawn state. */
5324 /* Make the frame visible (mapped and not iconified). */
5326 x_make_frame_invisible (f
)
5332 #ifdef USE_X_TOOLKIT
5333 /* Use the frame's outermost window, not the one we normally draw on. */
5334 window
= XtWindow (f
->output_data
.x
->widget
);
5335 #else /* not USE_X_TOOLKIT */
5336 window
= FRAME_X_WINDOW (f
);
5337 #endif /* not USE_X_TOOLKIT */
5339 /* Don't keep the highlight on an invisible frame. */
5340 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5341 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5343 #if 0/* This might add unreliability; I don't trust it -- rms. */
5344 if (! f
->async_visible
&& ! f
->async_iconified
)
5350 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
5351 that the current position of the window is user-specified, rather than
5352 program-specified, so that when the window is mapped again, it will be
5353 placed at the same location, without forcing the user to position it
5354 by hand again (they have already done that once for this window.) */
5355 x_wm_set_size_hint (f
, (long) 0, 1);
5359 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
5360 DefaultScreen (FRAME_X_DISPLAY (f
))))
5362 UNBLOCK_INPUT_RESIGNAL
;
5363 error ("Can't notify window manager of window withdrawal");
5365 #else /* ! defined (HAVE_X11R4) */
5367 /* Tell the window manager what we're going to do. */
5368 if (! EQ (Vx_no_window_manager
, Qt
))
5372 unmap
.xunmap
.type
= UnmapNotify
;
5373 unmap
.xunmap
.window
= window
;
5374 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
5375 unmap
.xunmap
.from_configure
= False
;
5376 if (! XSendEvent (FRAME_X_DISPLAY (f
),
5377 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
5379 SubstructureRedirectMask
|SubstructureNotifyMask
,
5382 UNBLOCK_INPUT_RESIGNAL
;
5383 error ("Can't notify window manager of withdrawal");
5387 /* Unmap the window ourselves. Cheeky! */
5388 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
5389 #endif /* ! defined (HAVE_X11R4) */
5391 /* We can't distinguish this from iconification
5392 just by the event that we get from the server.
5393 So we can't win using the usual strategy of letting
5394 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5395 and synchronize with the server to make sure we agree. */
5397 FRAME_ICONIFIED_P (f
) = 0;
5398 f
->async_visible
= 0;
5399 f
->async_iconified
= 0;
5406 /* Change window state from mapped to iconified. */
5415 /* Don't keep the highlight on an invisible frame. */
5416 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5417 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5419 if (f
->async_iconified
)
5424 FRAME_SAMPLE_VISIBILITY (f
);
5426 type
= x_icon_type (f
);
5428 x_bitmap_icon (f
, type
);
5430 #ifdef USE_X_TOOLKIT
5432 if (! FRAME_VISIBLE_P (f
))
5434 if (! EQ (Vx_no_window_manager
, Qt
))
5435 x_wm_set_window_state (f
, IconicState
);
5436 /* This was XtPopup, but that did nothing for an iconified frame. */
5437 XtMapWidget (f
->output_data
.x
->widget
);
5438 /* The server won't give us any event to indicate
5439 that an invisible frame was changed to an icon,
5440 so we have to record it here. */
5442 f
->async_iconified
= 1;
5447 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
5448 XtWindow (f
->output_data
.x
->widget
),
5449 DefaultScreen (FRAME_X_DISPLAY (f
)));
5453 error ("Can't notify window manager of iconification");
5455 f
->async_iconified
= 1;
5458 XFlush (FRAME_X_DISPLAY (f
));
5460 #else /* not USE_X_TOOLKIT */
5462 /* Make sure the X server knows where the window should be positioned,
5463 in case the user deiconifies with the window manager. */
5464 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
5465 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
5467 /* Since we don't know which revision of X we're running, we'll use both
5468 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
5470 /* X11R4: send a ClientMessage to the window manager using the
5471 WM_CHANGE_STATE type. */
5475 message
.xclient
.window
= FRAME_X_WINDOW (f
);
5476 message
.xclient
.type
= ClientMessage
;
5477 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
5478 message
.xclient
.format
= 32;
5479 message
.xclient
.data
.l
[0] = IconicState
;
5481 if (! XSendEvent (FRAME_X_DISPLAY (f
),
5482 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
5484 SubstructureRedirectMask
| SubstructureNotifyMask
,
5487 UNBLOCK_INPUT_RESIGNAL
;
5488 error ("Can't notify window manager of iconification");
5492 /* X11R3: set the initial_state field of the window manager hints to
5494 x_wm_set_window_state (f
, IconicState
);
5496 if (!FRAME_VISIBLE_P (f
))
5498 /* If the frame was withdrawn, before, we must map it. */
5499 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5502 f
->async_iconified
= 1;
5504 XFlush (FRAME_X_DISPLAY (f
));
5506 #endif /* not USE_X_TOOLKIT */
5509 /* Destroy the X window of frame F. */
5511 x_destroy_window (f
)
5514 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5518 /* If a display connection is dead, don't try sending more
5519 commands to the X server. */
5520 if (dpyinfo
->display
!= 0)
5522 if (f
->output_data
.x
->icon_desc
!= 0)
5523 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
5527 XDestroyIC (FRAME_XIC (f
));
5528 #if ! defined (SOLARIS2) || defined (HAVE_X11R6)
5529 /* This line causes crashes on Solaris with Openwin,
5530 due to an apparent bug in XCloseIM.
5531 X11R6 seems not to have the bug. */
5532 XCloseIM (FRAME_XIM (f
));
5536 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->window_desc
);
5537 #ifdef USE_X_TOOLKIT
5538 XtDestroyWidget (f
->output_data
.x
->widget
);
5539 free_frame_menubar (f
);
5540 #endif /* USE_X_TOOLKIT */
5542 free_frame_faces (f
);
5543 XFlush (FRAME_X_DISPLAY (f
));
5546 xfree (f
->output_data
.x
);
5547 f
->output_data
.x
= 0;
5548 if (f
== dpyinfo
->x_focus_frame
)
5549 dpyinfo
->x_focus_frame
= 0;
5550 if (f
== dpyinfo
->x_focus_event_frame
)
5551 dpyinfo
->x_focus_event_frame
= 0;
5552 if (f
== dpyinfo
->x_highlight_frame
)
5553 dpyinfo
->x_highlight_frame
= 0;
5555 dpyinfo
->reference_count
--;
5557 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5559 dpyinfo
->mouse_face_beg_row
5560 = dpyinfo
->mouse_face_beg_col
= -1;
5561 dpyinfo
->mouse_face_end_row
5562 = dpyinfo
->mouse_face_end_col
= -1;
5563 dpyinfo
->mouse_face_window
= Qnil
;
5569 /* Setting window manager hints. */
5571 /* Set the normal size hints for the window manager, for frame F.
5572 FLAGS is the flags word to use--or 0 meaning preserve the flags
5573 that the window now has.
5574 If USER_POSITION is nonzero, we set the USPosition
5575 flag (this is useful when FLAGS is 0). */
5577 x_wm_set_size_hint (f
, flags
, user_position
)
5582 XSizeHints size_hints
;
5584 #ifdef USE_X_TOOLKIT
5587 Dimension widget_width
, widget_height
;
5588 Window window
= XtWindow (f
->output_data
.x
->widget
);
5589 #else /* not USE_X_TOOLKIT */
5590 Window window
= FRAME_X_WINDOW (f
);
5591 #endif /* not USE_X_TOOLKIT */
5593 /* Setting PMaxSize caused various problems. */
5594 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
5596 flexlines
= f
->height
;
5598 size_hints
.x
= f
->output_data
.x
->left_pos
;
5599 size_hints
.y
= f
->output_data
.x
->top_pos
;
5601 #ifdef USE_X_TOOLKIT
5602 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
5603 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
5604 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
5605 size_hints
.height
= widget_height
;
5606 size_hints
.width
= widget_width
;
5607 #else /* not USE_X_TOOLKIT */
5608 size_hints
.height
= PIXEL_HEIGHT (f
);
5609 size_hints
.width
= PIXEL_WIDTH (f
);
5610 #endif /* not USE_X_TOOLKIT */
5612 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
5613 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
5614 size_hints
.max_width
5615 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
5616 size_hints
.max_height
5617 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
5619 /* Calculate the base and minimum sizes.
5621 (When we use the X toolkit, we don't do it here.
5622 Instead we copy the values that the widgets are using, below.) */
5623 #ifndef USE_X_TOOLKIT
5625 int base_width
, base_height
;
5626 int min_rows
= 0, min_cols
= 0;
5628 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
5629 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
5631 check_frame_size (f
, &min_rows
, &min_cols
);
5633 /* The window manager uses the base width hints to calculate the
5634 current number of rows and columns in the frame while
5635 resizing; min_width and min_height aren't useful for this
5636 purpose, since they might not give the dimensions for a
5637 zero-row, zero-column frame.
5639 We use the base_width and base_height members if we have
5640 them; otherwise, we set the min_width and min_height members
5641 to the size for a zero x zero frame. */
5644 size_hints
.flags
|= PBaseSize
;
5645 size_hints
.base_width
= base_width
;
5646 size_hints
.base_height
= base_height
;
5647 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
5648 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
5650 size_hints
.min_width
= base_width
;
5651 size_hints
.min_height
= base_height
;
5655 /* If we don't need the old flags, we don't need the old hint at all. */
5658 size_hints
.flags
|= flags
;
5661 #endif /* not USE_X_TOOLKIT */
5664 XSizeHints hints
; /* Sometimes I hate X Windows... */
5665 long supplied_return
;
5669 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
5672 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
5675 #ifdef USE_X_TOOLKIT
5676 size_hints
.base_height
= hints
.base_height
;
5677 size_hints
.base_width
= hints
.base_width
;
5678 size_hints
.min_height
= hints
.min_height
;
5679 size_hints
.min_width
= hints
.min_width
;
5683 size_hints
.flags
|= flags
;
5688 if (hints
.flags
& PSize
)
5689 size_hints
.flags
|= PSize
;
5690 if (hints
.flags
& PPosition
)
5691 size_hints
.flags
|= PPosition
;
5692 if (hints
.flags
& USPosition
)
5693 size_hints
.flags
|= USPosition
;
5694 if (hints
.flags
& USSize
)
5695 size_hints
.flags
|= USSize
;
5702 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
5703 size_hints
.flags
|= PWinGravity
;
5707 size_hints
.flags
&= ~ PPosition
;
5708 size_hints
.flags
|= USPosition
;
5710 #endif /* PWinGravity */
5713 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
5715 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
5719 /* Used for IconicState or NormalState */
5720 x_wm_set_window_state (f
, state
)
5724 #ifdef USE_X_TOOLKIT
5727 XtSetArg (al
[0], XtNinitialState
, state
);
5728 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
5729 #else /* not USE_X_TOOLKIT */
5730 Window window
= FRAME_X_WINDOW (f
);
5732 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
5733 f
->output_data
.x
->wm_hints
.initial_state
= state
;
5735 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5736 #endif /* not USE_X_TOOLKIT */
5739 x_wm_set_icon_pixmap (f
, pixmap_id
)
5745 #ifdef USE_X_TOOLKIT
5746 Window window
= XtWindow (f
->output_data
.x
->widget
);
5748 Window window
= FRAME_X_WINDOW (f
);
5753 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
5754 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
5758 /* It seems there is no way to turn off use of an icon pixmap.
5759 The following line does it, only if no icon has yet been created,
5760 for some window managers. But with mwm it crashes.
5761 Some people say it should clear the IconPixmapHint bit in this case,
5762 but that doesn't work, and the X consortium said it isn't the
5763 right thing at all. Since there is no way to win,
5764 best to explicitly give up. */
5766 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
5772 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
5776 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
5777 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
5780 #else /* not USE_X_TOOLKIT */
5782 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
5783 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5785 #endif /* not USE_X_TOOLKIT */
5788 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5792 #ifdef USE_X_TOOLKIT
5793 Window window
= XtWindow (f
->output_data
.x
->widget
);
5795 Window window
= FRAME_X_WINDOW (f
);
5798 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
5799 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
5800 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
5802 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5806 /* Initialization. */
5808 #ifdef USE_X_TOOLKIT
5809 static XrmOptionDescRec emacs_options
[] = {
5810 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
5811 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
5813 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
5814 XrmoptionSepArg
, NULL
},
5815 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
5817 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5818 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5819 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5820 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5821 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5822 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
5823 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
5825 #endif /* USE_X_TOOLKIT */
5827 static int x_initialized
;
5830 /* Test whether two display-name strings agree up to the dot that separates
5831 the screen number from the server number. */
5833 same_x_server (name1
, name2
)
5834 char *name1
, *name2
;
5837 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
5841 if (seen_colon
&& *name1
== '.')
5845 && (*name1
== '.' || *name1
== '\0')
5846 && (*name2
== '.' || *name2
== '\0'));
5850 struct x_display_info
*
5851 x_term_init (display_name
, xrm_option
, resource_name
)
5852 Lisp_Object display_name
;
5854 char *resource_name
;
5860 struct x_display_info
*dpyinfo
;
5872 setlocale (LC_ALL
, "");
5873 /* In case we just overrode what init_lread did, redo it. */
5874 setlocale (LC_NUMERIC
, "C");
5875 setlocale (LC_TIME
, "C");
5878 #ifdef USE_X_TOOLKIT
5879 /* weiner@footloose.sps.mot.com reports that this causes
5881 X protocol error: BadAtom (invalid Atom parameter)
5882 on protocol request 18skiloaf.
5883 So let's not use it until R6. */
5885 XtSetLanguageProc (NULL
, NULL
, NULL
);
5896 argv
[argc
++] = "-xrm";
5897 argv
[argc
++] = xrm_option
;
5899 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
5900 resource_name
, EMACS_CLASS
,
5901 emacs_options
, XtNumber (emacs_options
),
5905 /* I think this is to compensate for XtSetLanguageProc. */
5906 setlocale (LC_NUMERIC
, "C");
5907 setlocale (LC_TIME
, "C");
5911 #else /* not USE_X_TOOLKIT */
5913 XSetLocaleModifiers ("");
5915 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
5916 #endif /* not USE_X_TOOLKIT */
5918 /* Detect failure. */
5925 /* We have definitely succeeded. Record the new connection. */
5927 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
5931 struct x_display_info
*share
;
5934 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
5935 share
= share
->next
, tail
= XCONS (tail
)->cdr
)
5936 if (same_x_server (XSTRING (XCONS (XCONS (tail
)->car
)->car
)->data
,
5937 XSTRING (display_name
)->data
))
5940 dpyinfo
->kboard
= share
->kboard
;
5943 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
5944 init_kboard (dpyinfo
->kboard
);
5945 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
5947 char *vendor
= ServerVendor (dpy
);
5948 dpyinfo
->kboard
->Vsystem_key_alist
5949 = call1 (Qvendor_specific_keysyms
,
5950 build_string (vendor
? vendor
: ""));
5953 dpyinfo
->kboard
->next_kboard
= all_kboards
;
5954 all_kboards
= dpyinfo
->kboard
;
5955 /* Don't let the initial kboard remain current longer than necessary.
5956 That would cause problems if a file loaded on startup tries to
5957 prompt in the minibuffer. */
5958 if (current_kboard
== initial_kboard
)
5959 current_kboard
= dpyinfo
->kboard
;
5961 dpyinfo
->kboard
->reference_count
++;
5965 /* Put this display on the chain. */
5966 dpyinfo
->next
= x_display_list
;
5967 x_display_list
= dpyinfo
;
5969 /* Put it on x_display_name_list as well, to keep them parallel. */
5970 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
5971 x_display_name_list
);
5972 dpyinfo
->name_list_element
= XCONS (x_display_name_list
)->car
;
5974 dpyinfo
->display
= dpy
;
5977 XSetAfterFunction (x_current_display
, x_trace_wire
);
5981 = (char *) xmalloc (XSTRING (Vinvocation_name
)->size
5982 + XSTRING (Vsystem_name
)->size
5984 sprintf (dpyinfo
->x_id_name
, "%s@%s",
5985 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
5987 /* Figure out which modifier bits mean what. */
5988 x_find_modifier_meanings (dpyinfo
);
5990 /* Get the scroll bar cursor. */
5991 dpyinfo
->vertical_scroll_bar_cursor
5992 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
5994 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
5995 resource_name
, EMACS_CLASS
);
5996 #ifdef HAVE_XRMSETDATABASE
5997 XrmSetDatabase (dpyinfo
->display
, xrdb
);
5999 dpyinfo
->display
->db
= xrdb
;
6001 /* Put the rdb where we can find it in a way that works on
6003 dpyinfo
->xrdb
= xrdb
;
6005 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
6006 DefaultScreen (dpyinfo
->display
));
6007 dpyinfo
->visual
= select_visual (dpyinfo
->display
, dpyinfo
->screen
,
6008 &dpyinfo
->n_planes
);
6009 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
6010 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
6011 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
6012 dpyinfo
->grabbed
= 0;
6013 dpyinfo
->reference_count
= 0;
6014 dpyinfo
->icon_bitmap_id
= -1;
6015 dpyinfo
->n_fonts
= 0;
6016 dpyinfo
->font_table_size
= 0;
6017 dpyinfo
->bitmaps
= 0;
6018 dpyinfo
->bitmaps_size
= 0;
6019 dpyinfo
->bitmaps_last
= 0;
6020 dpyinfo
->scratch_cursor_gc
= 0;
6021 dpyinfo
->mouse_face_mouse_frame
= 0;
6022 dpyinfo
->mouse_face_deferred_gc
= 0;
6023 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6024 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6025 dpyinfo
->mouse_face_face_id
= 0;
6026 dpyinfo
->mouse_face_window
= Qnil
;
6027 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
6028 dpyinfo
->mouse_face_defer
= 0;
6029 dpyinfo
->x_focus_frame
= 0;
6030 dpyinfo
->x_focus_event_frame
= 0;
6031 dpyinfo
->x_highlight_frame
= 0;
6033 dpyinfo
->Xatom_wm_protocols
6034 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
6035 dpyinfo
->Xatom_wm_take_focus
6036 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
6037 dpyinfo
->Xatom_wm_save_yourself
6038 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
6039 dpyinfo
->Xatom_wm_delete_window
6040 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
6041 dpyinfo
->Xatom_wm_change_state
6042 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
6043 dpyinfo
->Xatom_wm_configure_denied
6044 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
6045 dpyinfo
->Xatom_wm_window_moved
6046 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
6047 dpyinfo
->Xatom_editres
6048 = XInternAtom (dpyinfo
->display
, "Editres", False
);
6050 = XInternAtom (dpyinfo
->display
, "FONT", False
);
6051 dpyinfo
->Xatom_CLIPBOARD
6052 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
6053 dpyinfo
->Xatom_TIMESTAMP
6054 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
6056 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
6057 dpyinfo
->Xatom_DELETE
6058 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
6059 dpyinfo
->Xatom_MULTIPLE
6060 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
6062 = XInternAtom (dpyinfo
->display
, "INCR", False
);
6063 dpyinfo
->Xatom_EMACS_TMP
6064 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
6065 dpyinfo
->Xatom_TARGETS
6066 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
6068 = XInternAtom (dpyinfo
->display
, "NULL", False
);
6069 dpyinfo
->Xatom_ATOM_PAIR
6070 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
6072 dpyinfo
->cut_buffers_initialized
= 0;
6074 connection
= ConnectionNumber (dpyinfo
->display
);
6075 dpyinfo
->connection
= connection
;
6078 /* This is only needed for distinguishing keyboard and process input. */
6079 if (connection
!= 0)
6080 add_keyboard_wait_descriptor (connection
);
6083 #ifndef F_SETOWN_BUG
6085 #ifdef F_SETOWN_SOCK_NEG
6086 /* stdin is a socket here */
6087 fcntl (connection
, F_SETOWN
, -getpid ());
6088 #else /* ! defined (F_SETOWN_SOCK_NEG) */
6089 fcntl (connection
, F_SETOWN
, getpid ());
6090 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
6091 #endif /* ! defined (F_SETOWN) */
6092 #endif /* F_SETOWN_BUG */
6095 if (interrupt_input
)
6096 init_sigio (connection
);
6097 #endif /* ! defined (SIGIO) */
6100 /* Make sure that we have a valid font for dialog boxes
6101 so that Xt does not crash. */
6103 Display
*dpy
= dpyinfo
->display
;
6107 d
.addr
= (XPointer
)&dpy
;
6108 d
.size
= sizeof (Display
*);
6109 fr
.addr
= XtDefaultFont
;
6110 fr
.size
= sizeof (XtDefaultFont
);
6111 to
.size
= sizeof (Font
*);
6112 to
.addr
= (XPointer
)&font
;
6113 x_catch_errors (dpy
);
6114 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
6116 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
6117 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
6118 x_uncatch_errors (dpy
);
6128 /* Get rid of display DPYINFO, assuming all frames are already gone,
6129 and without sending any more commands to the X server. */
6132 x_delete_display (dpyinfo
)
6133 struct x_display_info
*dpyinfo
;
6135 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
6137 /* Discard this display from x_display_name_list and x_display_list.
6138 We can't use Fdelq because that can quit. */
6139 if (! NILP (x_display_name_list
)
6140 && EQ (XCONS (x_display_name_list
)->car
, dpyinfo
->name_list_element
))
6141 x_display_name_list
= XCONS (x_display_name_list
)->cdr
;
6146 tail
= x_display_name_list
;
6147 while (CONSP (tail
) && CONSP (XCONS (tail
)->cdr
))
6149 if (EQ (XCONS (XCONS (tail
)->cdr
)->car
,
6150 dpyinfo
->name_list_element
))
6152 XCONS (tail
)->cdr
= XCONS (XCONS (tail
)->cdr
)->cdr
;
6155 tail
= XCONS (tail
)->cdr
;
6159 if (x_display_list
== dpyinfo
)
6160 x_display_list
= dpyinfo
->next
;
6163 struct x_display_info
*tail
;
6165 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
6166 if (tail
->next
== dpyinfo
)
6167 tail
->next
= tail
->next
->next
;
6170 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
6171 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
6172 XrmDestroyDatabase (dpyinfo
->xrdb
);
6176 if (--dpyinfo
->kboard
->reference_count
== 0)
6177 delete_kboard (dpyinfo
->kboard
);
6179 xfree (dpyinfo
->font_table
);
6180 xfree (dpyinfo
->x_id_name
);
6184 /* Set up use of X before we make the first connection. */
6188 clear_frame_hook
= XTclear_frame
;
6189 clear_end_of_line_hook
= XTclear_end_of_line
;
6190 ins_del_lines_hook
= XTins_del_lines
;
6191 change_line_highlight_hook
= XTchange_line_highlight
;
6192 insert_glyphs_hook
= XTinsert_glyphs
;
6193 write_glyphs_hook
= XTwrite_glyphs
;
6194 delete_glyphs_hook
= XTdelete_glyphs
;
6195 ring_bell_hook
= XTring_bell
;
6196 reset_terminal_modes_hook
= XTreset_terminal_modes
;
6197 set_terminal_modes_hook
= XTset_terminal_modes
;
6198 update_begin_hook
= XTupdate_begin
;
6199 update_end_hook
= XTupdate_end
;
6200 set_terminal_window_hook
= XTset_terminal_window
;
6201 read_socket_hook
= XTread_socket
;
6202 frame_up_to_date_hook
= XTframe_up_to_date
;
6203 cursor_to_hook
= XTcursor_to
;
6204 reassert_line_highlight_hook
= XTreassert_line_highlight
;
6205 mouse_position_hook
= XTmouse_position
;
6206 frame_rehighlight_hook
= XTframe_rehighlight
;
6207 frame_raise_lower_hook
= XTframe_raise_lower
;
6208 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
6209 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
6210 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
6211 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
6213 scroll_region_ok
= 1; /* we'll scroll partial frames */
6214 char_ins_del_ok
= 0; /* just as fast to write the line */
6215 line_ins_del_ok
= 1; /* we'll just blt 'em */
6216 fast_clear_end_of_line
= 1; /* X does this well */
6217 memory_below_frame
= 0; /* we don't remember what scrolls
6223 /* Try to use interrupt input; if we can't, then start polling. */
6224 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
6226 #ifdef USE_X_TOOLKIT
6227 XtToolkitInitialize ();
6228 Xt_app_con
= XtCreateApplicationContext ();
6229 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
6232 /* Note that there is no real way portable across R3/R4 to get the
6233 original error handler. */
6234 XSetErrorHandler (x_error_quitter
);
6235 XSetIOErrorHandler (x_io_error_quitter
);
6237 /* Disable Window Change signals; they are handled by X events. */
6239 signal (SIGWINCH
, SIG_DFL
);
6240 #endif /* ! defined (SIGWINCH) */
6242 signal (SIGPIPE
, x_connection_signal
);
6248 staticpro (&x_display_name_list
);
6249 x_display_name_list
= Qnil
;
6251 staticpro (&last_mouse_scroll_bar
);
6252 last_mouse_scroll_bar
= Qnil
;
6254 staticpro (&Qvendor_specific_keysyms
);
6255 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
6257 staticpro (&last_mouse_press_frame
);
6258 last_mouse_press_frame
= Qnil
;
6261 #endif /* not HAVE_X_WINDOWS */