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) */
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 /* The scroll bar in which the last X motion event occurred.
202 If the last X motion event occurred in a scroll bar, we set this
203 so XTmouse_position can know whether to report a scroll bar motion or
206 If the last X motion event didn't occur in a scroll bar, we set this
207 to Qnil, to tell XTmouse_position to return an ordinary motion event. */
208 static Lisp_Object last_mouse_scroll_bar
;
210 /* This is a hack. We would really prefer that XTmouse_position would
211 return the time associated with the position it returns, but there
212 doesn't seem to be any way to wrest the timestamp from the server
213 along with the position query. So, we just keep track of the time
214 of the last movement we received, and return that in hopes that
215 it's somewhat accurate. */
216 static Time last_mouse_movement_time
;
218 /* Incremented by XTread_socket whenever it really tries to read events. */
220 static int volatile input_signal_count
;
222 static int input_signal_count
;
225 /* Used locally within XTread_socket. */
226 static int x_noop_count
;
228 /* Initial values of argv and argc. */
229 extern char **initial_argv
;
230 extern int initial_argc
;
232 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
234 /* Tells if a window manager is present or not. */
236 extern Lisp_Object Vx_no_window_manager
;
238 extern Lisp_Object Qface
, Qmouse_face
;
242 /* A mask of extra modifier bits to put into every keyboard char. */
243 extern int extra_keyboard_modifiers
;
245 static Lisp_Object Qvendor_specific_keysyms
;
247 extern XrmDatabase
x_load_resources ();
249 extern Lisp_Object
x_icon_type ();
251 void x_delete_display ();
253 static void redraw_previous_char ();
254 static void redraw_following_char ();
255 static unsigned int x_x_to_emacs_modifiers ();
257 static int fast_find_position ();
258 static void note_mouse_highlight ();
259 static void clear_mouse_face ();
260 static void show_mouse_face ();
261 static void do_line_dance ();
263 static int XTcursor_to ();
264 static int XTclear_end_of_line ();
265 static int x_io_error_quitter ();
266 void x_catch_errors ();
267 void x_uncatch_errors ();
270 /* This is a function useful for recording debugging information
271 about the sequence of occurrences in this file. */
279 struct record event_record
[100];
281 int event_record_index
;
283 record_event (locus
, type
)
287 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
288 event_record_index
= 0;
290 event_record
[event_record_index
].locus
= locus
;
291 event_record
[event_record_index
].type
= type
;
292 event_record_index
++;
297 /* Return the struct x_display_info corresponding to DPY. */
299 struct x_display_info
*
300 x_display_info_for_display (dpy
)
303 struct x_display_info
*dpyinfo
;
305 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
306 if (dpyinfo
->display
== dpy
)
312 /* Starting and ending updates.
314 These hooks are called by update_frame at the beginning and end
315 of a frame update. We record in `updating_frame' the identity
316 of the frame being updated, so that the XT... functions do not
317 need to take a frame as argument. Most of the XT... functions
318 should never be called except during an update, the only exceptions
319 being XTcursor_to, XTwrite_glyphs and XTreassert_line_highlight. */
330 flexlines
= f
->height
;
335 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
337 /* Don't do highlighting for mouse motion during the update. */
338 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 1;
340 /* If the frame needs to be redrawn,
341 simply forget about any prior mouse highlighting. */
342 if (FRAME_GARBAGED_P (f
))
343 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= Qnil
;
345 if (!NILP (FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
))
347 int firstline
, lastline
, i
;
348 struct window
*w
= XWINDOW (FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
);
350 /* Find the first, and the last+1, lines affected by redisplay. */
351 for (firstline
= 0; firstline
< f
->height
; firstline
++)
352 if (FRAME_DESIRED_GLYPHS (f
)->enable
[firstline
])
355 lastline
= f
->height
;
356 for (i
= f
->height
- 1; i
>= 0; i
--)
358 if (FRAME_DESIRED_GLYPHS (f
)->enable
[i
])
364 /* Can we tell that this update does not affect the window
365 where the mouse highlight is? If so, no need to turn off.
366 Likewise, don't do anything if the frame is garbaged;
367 in that case, the FRAME_CURRENT_GLYPHS that we would use
368 are all wrong, and we will redisplay that line anyway. */
369 if (! (firstline
> (XFASTINT (w
->top
) + window_internal_height (w
))
370 || lastline
< XFASTINT (w
->top
)))
371 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
387 x_display_cursor (f
, 1);
389 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
390 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
392 /* This fails in the case of having updated only the echo area
393 if we have switched buffers. In that case, FRAME_CURRENT_GLYPHS
394 has no relation to the current contents, and its charstarts
395 have no relation to the contents of the window-buffer.
396 I don't know a clean way to check
397 for that case. window_end_valid isn't set up yet. */
398 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
399 note_mouse_highlight (f
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
400 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
403 XFlush (FRAME_X_DISPLAY (f
));
407 /* This is called after a redisplay on frame F. */
410 XTframe_up_to_date (f
)
414 if (FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
415 || f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
417 note_mouse_highlight (FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
,
418 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
419 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
420 FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 0;
425 /* External interface to control of standout mode.
426 Call this when about to modify line at position VPOS
427 and not change whether it is highlighted. */
429 XTreassert_line_highlight (new, vpos
)
435 /* Call this when about to modify line at position VPOS
436 and change whether it is highlighted. */
439 XTchange_line_highlight (new_highlight
, vpos
, first_unused_hpos
)
440 int new_highlight
, vpos
, first_unused_hpos
;
442 highlight
= new_highlight
;
443 XTcursor_to (vpos
, 0);
444 XTclear_end_of_line (updating_frame
->width
);
447 /* This is used when starting Emacs and when restarting after suspend.
448 When starting Emacs, no X window is mapped. And nothing must be done
449 to Emacs's own window if it is suspended (though that rarely happens). */
452 XTset_terminal_modes ()
456 /* This is called when exiting or suspending Emacs.
457 Exiting will make the X-windows go away, and suspending
458 requires no action. */
461 XTreset_terminal_modes ()
463 /* XTclear_frame (); */
466 /* Set the nominal cursor position of the frame.
467 This is where display update commands will take effect.
468 This does not affect the place where the cursor-box is displayed. */
471 XTcursor_to (row
, col
)
472 register int row
, col
;
480 if (updating_frame
== 0)
483 x_display_cursor (selected_frame
, 1);
484 XFlush (FRAME_X_DISPLAY (selected_frame
));
489 /* Display a sequence of N glyphs found at GP.
490 WINDOW is the x-window to output to. LEFT and TOP are starting coords.
491 HL is 1 if this text is highlighted, 2 if the cursor is on it,
492 3 if should appear in its mouse-face.
493 JUST_FOREGROUND if 1 means draw only the foreground;
494 don't alter the background.
496 FONT is the default font to use (for glyphs whose font-code is 0).
498 Since the display generation code is responsible for calling
499 compute_char_face and compute_glyph_face on everything it puts in
500 the display structure, we can assume that the face code on each
501 glyph is a valid index into FRAME_COMPUTED_FACES (f), and the one
502 to which we can actually apply intern_face.
503 Call this function with input blocked. */
506 /* This is the multi-face code. */
509 dumpglyphs (f
, left
, top
, gp
, n
, hl
, just_foreground
)
512 register GLYPH
*gp
; /* Points to first GLYPH. */
513 register int n
; /* Number of glyphs to display. */
517 /* Holds characters to be displayed. */
518 char *buf
= (char *) alloca (f
->width
* sizeof (*buf
));
519 register char *cp
; /* Steps through buf[]. */
520 register int tlen
= GLYPH_TABLE_LENGTH
;
521 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
522 Window window
= FRAME_X_WINDOW (f
);
523 int orig_left
= left
;
527 /* Get the face-code of the next GLYPH. */
531 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
532 cf
= FAST_GLYPH_FACE (g
);
534 /* Find the run of consecutive glyphs with the same face-code.
535 Extract their character codes into BUF. */
540 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
541 if (FAST_GLYPH_FACE (g
) != cf
)
544 *cp
++ = FAST_GLYPH_CHAR (g
);
549 /* LEN gets the length of the run. */
552 /* Now output this run of chars, with the font and pixel values
553 determined by the face code CF. */
555 struct face
*face
= FRAME_DEFAULT_FACE (f
);
556 XFontStruct
*font
= FACE_FONT (face
);
557 GC gc
= FACE_GC (face
);
560 /* HL = 3 means use a mouse face previously chosen. */
562 cf
= FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
;
564 /* First look at the face of the text itself. */
567 /* It's possible for the display table to specify
568 a face code that is out of range. Use 0 in that case. */
569 if (cf
< 0 || cf
>= FRAME_N_COMPUTED_FACES (f
)
570 || FRAME_COMPUTED_FACES (f
) [cf
] == 0)
574 face
= FRAME_MODE_LINE_FACE (f
);
576 face
= intern_face (f
, FRAME_COMPUTED_FACES (f
) [cf
]);
577 font
= FACE_FONT (face
);
579 if (FACE_STIPPLE (face
))
583 /* Then comes the distinction between modeline and normal text. */
588 face
= FRAME_MODE_LINE_FACE (f
);
589 font
= FACE_FONT (face
);
591 if (FACE_STIPPLE (face
))
595 #define FACE_DEFAULT (~0)
597 /* Now override that if the cursor's on this character. */
600 /* The cursor overrides stippling. */
604 || face
->font
== (XFontStruct
*) FACE_DEFAULT
605 || face
->font
== f
->output_data
.x
->font
)
606 && face
->background
== f
->output_data
.x
->background_pixel
607 && face
->foreground
== f
->output_data
.x
->foreground_pixel
)
609 gc
= f
->output_data
.x
->cursor_gc
;
611 /* Cursor on non-default face: must merge. */
617 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
618 xgcv
.foreground
= face
->background
;
619 /* If the glyph would be invisible,
620 try a different foreground. */
621 if (xgcv
.foreground
== xgcv
.background
)
622 xgcv
.foreground
= face
->foreground
;
623 if (xgcv
.foreground
== xgcv
.background
)
624 xgcv
.foreground
= f
->output_data
.x
->cursor_foreground_pixel
;
625 if (xgcv
.foreground
== xgcv
.background
)
626 xgcv
.foreground
= face
->foreground
;
627 /* Make sure the cursor is distinct from text in this face. */
628 if (xgcv
.background
== face
->background
629 && xgcv
.foreground
== face
->foreground
)
631 xgcv
.background
= face
->foreground
;
632 xgcv
.foreground
= face
->background
;
634 xgcv
.font
= face
->font
->fid
;
635 xgcv
.graphics_exposures
= 0;
636 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
637 if (FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
)
638 XChangeGC (FRAME_X_DISPLAY (f
),
639 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
,
642 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
643 = XCreateGC (FRAME_X_DISPLAY (f
), window
, mask
, &xgcv
);
644 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
646 /* If this code is restored, it must also reset to the default stipple
648 if (face
->stipple
&& face
->stipple
!= FACE_DEFAULT
)
649 XSetStipple (FRAME_X_DISPLAY (f
), gc
, face
->stipple
);
654 if (font
== (XFontStruct
*) FACE_DEFAULT
)
655 font
= f
->output_data
.x
->font
;
658 XDrawString (FRAME_X_DISPLAY (f
), window
, gc
,
659 left
, top
+ FONT_BASE (font
), buf
, len
);
664 /* Turn stipple on. */
665 XSetFillStyle (FRAME_X_DISPLAY (f
), gc
, FillOpaqueStippled
);
667 /* Draw stipple on background. */
668 XFillRectangle (FRAME_X_DISPLAY (f
), window
, gc
,
670 FONT_WIDTH (font
) * len
,
673 /* Turn stipple off. */
674 XSetFillStyle (FRAME_X_DISPLAY (f
), gc
, FillSolid
);
676 /* Draw the text, solidly, onto the stipple pattern. */
677 XDrawString (FRAME_X_DISPLAY (f
), window
, gc
,
678 left
, top
+ FONT_BASE (font
), buf
, len
);
681 XDrawImageString (FRAME_X_DISPLAY (f
), window
, gc
,
682 left
, top
+ FONT_BASE (font
), buf
, len
);
684 /* Clear the rest of the line's height. */
685 if (f
->output_data
.x
->line_height
!= FONT_HEIGHT (font
))
686 XClearArea (FRAME_X_DISPLAY (f
), window
, left
,
687 top
+ FONT_HEIGHT (font
),
688 FONT_WIDTH (font
) * len
,
689 /* This is how many pixels of height
691 f
->output_data
.x
->line_height
- FONT_HEIGHT (font
),
695 #if 0 /* Doesn't work, because it uses FRAME_CURRENT_GLYPHS,
696 which often is not up to date yet. */
697 if (!just_foreground
)
699 if (left
== orig_left
)
700 redraw_previous_char (f
, PIXEL_TO_CHAR_COL (f
, left
),
701 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
703 redraw_following_char (f
, PIXEL_TO_CHAR_COL (f
, left
+ len
* FONT_WIDTH (font
)),
704 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
708 /* We should probably check for XA_UNDERLINE_POSITION and
709 XA_UNDERLINE_THICKNESS properties on the font, but let's
710 just get the thing working, and come back to that. */
712 int underline_position
= 1;
714 if (font
->descent
<= underline_position
)
715 underline_position
= font
->descent
- 1;
718 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
722 + underline_position
),
723 len
* FONT_WIDTH (font
), 1);
726 left
+= len
* FONT_WIDTH (font
);
733 /* This is the old single-face code. */
736 dumpglyphs (f
, left
, top
, gp
, n
, hl
, font
)
739 register GLYPH
*gp
; /* Points to first GLYPH. */
740 register int n
; /* Number of glyphs to display. */
745 Window window
= FRAME_X_WINDOW (f
);
746 GC drawing_gc
= (hl
== 2 ? f
->output_data
.x
->cursor_gc
747 : (hl
? f
->output_data
.x
->reverse_gc
748 : f
->output_data
.x
->normal_gc
));
750 if (sizeof (GLYPH
) == sizeof (XChar2b
))
751 XDrawImageString16 (FRAME_X_DISPLAY (f
), window
, drawing_gc
,
752 left
, top
+ FONT_BASE (font
), (XChar2b
*) gp
, n
);
753 else if (sizeof (GLYPH
) == sizeof (unsigned char))
754 XDrawImageString (FRAME_X_DISPLAY (f
), window
, drawing_gc
,
755 left
, top
+ FONT_BASE (font
), (char *) gp
, n
);
757 /* What size of glyph ARE you using? And does X have a function to
763 /* Output some text at the nominal frame cursor position.
764 Advance the cursor over the text.
765 Output LEN glyphs at START.
767 `highlight', set up by XTreassert_line_highlight or XTchange_line_highlight,
768 controls the pixel values used for foreground and background. */
771 XTwrite_glyphs (start
, len
)
772 register GLYPH
*start
;
775 register int temp_length
;
786 /* If not within an update,
787 output at the frame's visible cursor. */
788 curs_x
= f
->cursor_x
;
789 curs_y
= f
->cursor_y
;
793 CHAR_TO_PIXEL_COL (f
, curs_x
),
794 CHAR_TO_PIXEL_ROW (f
, curs_y
),
795 start
, len
, highlight
, 0);
797 /* If we drew on top of the cursor, note that it is turned off. */
798 if (curs_y
== f
->phys_cursor_y
799 && curs_x
<= f
->phys_cursor_x
800 && curs_x
+ len
> f
->phys_cursor_x
)
801 f
->phys_cursor_x
= -1;
803 if (updating_frame
== 0)
806 x_display_cursor (f
, 1);
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_display_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_display_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
)))
1918 int *ptr
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[row
];
1921 /* Find which buffer position the mouse corresponds to. */
1922 for (i
= column
; i
>= 0; i
--)
1926 /* Is it outside the displayed active region (if any)? */
1928 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1929 else if (! (EQ (window
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
)
1930 && row
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
1931 && row
<= FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
1932 && (row
> FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
1933 || column
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
)
1934 && (row
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
1935 || column
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
1936 || FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
)))
1938 Lisp_Object mouse_face
, overlay
, position
;
1939 Lisp_Object
*overlay_vec
;
1940 int len
, noverlays
, ignor1
;
1941 struct buffer
*obuf
;
1944 /* If we get an out-of-range value, return now; avoid an error. */
1945 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1948 /* Make the window's buffer temporarily current for
1949 overlays_at and compute_char_face. */
1950 obuf
= current_buffer
;
1951 current_buffer
= XBUFFER (w
->buffer
);
1957 /* Yes. Clear the display of the old active region, if any. */
1958 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1960 /* Is this char mouse-active? */
1961 XSETINT (position
, pos
);
1964 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1966 /* Put all the overlays we want in a vector in overlay_vec.
1967 Store the length in len. */
1968 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
1970 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1972 /* Find the highest priority overlay that has a mouse-face prop. */
1974 for (i
= 0; i
< noverlays
; i
++)
1976 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1977 if (!NILP (mouse_face
))
1979 overlay
= overlay_vec
[i
];
1984 /* If no overlay applies, get a text property. */
1986 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
1988 /* Handle the overlay case. */
1989 if (! NILP (overlay
))
1991 /* Find the range of text around this char that
1992 should be active. */
1993 Lisp_Object before
, after
;
1996 before
= Foverlay_start (overlay
);
1997 after
= Foverlay_end (overlay
);
1998 /* Record this as the current active region. */
1999 fast_find_position (window
, before
,
2000 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
,
2001 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
);
2002 FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
2003 = !fast_find_position (window
, after
,
2004 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
,
2005 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
);
2006 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= window
;
2007 FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
2008 = compute_char_face (f
, w
, pos
, 0, 0,
2009 &ignore
, pos
+ 1, 1);
2011 /* Display it as active. */
2012 show_mouse_face (FRAME_X_DISPLAY_INFO (f
), 1);
2014 /* Handle the text property case. */
2015 else if (! NILP (mouse_face
))
2017 /* Find the range of text around this char that
2018 should be active. */
2019 Lisp_Object before
, after
, beginning
, end
;
2022 beginning
= Fmarker_position (w
->start
);
2023 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
2024 - XFASTINT (w
->window_end_pos
)));
2026 = Fprevious_single_property_change (make_number (pos
+ 1),
2028 w
->buffer
, beginning
);
2030 = Fnext_single_property_change (position
, Qmouse_face
,
2032 /* Record this as the current active region. */
2033 fast_find_position (window
, before
,
2034 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
,
2035 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
);
2036 FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
2037 = !fast_find_position (window
, after
,
2038 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
,
2039 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
);
2040 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= window
;
2041 FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
2042 = compute_char_face (f
, w
, pos
, 0, 0,
2043 &ignore
, pos
+ 1, 1);
2045 /* Display it as active. */
2046 show_mouse_face (FRAME_X_DISPLAY_INFO (f
), 1);
2050 current_buffer
= obuf
;
2055 /* Find the row and column of position POS in window WINDOW.
2056 Store them in *COLUMNP and *ROWP.
2057 This assumes display in WINDOW is up to date.
2058 If POS is above start of WINDOW, return coords
2059 of start of first screen line.
2060 If POS is after end of WINDOW, return coords of end of last screen line.
2062 Value is 1 if POS is in range, 0 if it was off screen. */
2065 fast_find_position (window
, pos
, columnp
, rowp
)
2068 int *columnp
, *rowp
;
2070 struct window
*w
= XWINDOW (window
);
2071 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2076 int height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
2077 int width
= window_internal_width (w
);
2080 int maybe_next_line
= 0;
2082 /* Find the right row. */
2087 int linestart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ i
][left
];
2088 if (linestart
> pos
)
2090 /* If the position sought is the end of the buffer,
2091 don't include the blank lines at the bottom of the window. */
2092 if (linestart
== pos
&& pos
== BUF_ZV (XBUFFER (w
->buffer
)))
2094 maybe_next_line
= 1;
2101 /* Find the right column with in it. */
2102 charstarts
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ row
];
2104 for (i
= 0; i
< width
; i
++)
2106 if (charstarts
[left
+ i
] == pos
)
2109 *columnp
= i
+ left
;
2112 else if (charstarts
[left
+ i
] > pos
)
2114 else if (charstarts
[left
+ i
] > 0)
2118 /* If we're looking for the end of the buffer,
2119 and we didn't find it in the line we scanned,
2120 use the start of the following line. */
2121 if (maybe_next_line
)
2132 /* Display the active region described by mouse_face_*
2133 in its mouse-face if HL > 0, in its normal face if HL = 0. */
2136 show_mouse_face (dpyinfo
, hl
)
2137 struct x_display_info
*dpyinfo
;
2140 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
2141 int width
= window_internal_width (w
);
2142 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2145 int old_curs_x
= curs_x
;
2146 int old_curs_y
= curs_y
;
2148 /* Set these variables temporarily
2149 so that if we have to turn the cursor off and on again
2150 we will put it back at the same place. */
2151 curs_x
= f
->phys_cursor_x
;
2152 curs_y
= f
->phys_cursor_y
;
2154 for (i
= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
;
2155 i
<= FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
; i
++)
2157 int column
= (i
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
2158 ? FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
2160 int endcolumn
= (i
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
2161 ? FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
2163 endcolumn
= min (endcolumn
, FRAME_CURRENT_GLYPHS (f
)->used
[i
]);
2165 /* If the cursor's in the text we are about to rewrite,
2166 turn the cursor off. */
2168 && curs_x
>= column
- 1
2169 && curs_x
<= endcolumn
)
2171 x_display_cursor (f
, 0);
2176 CHAR_TO_PIXEL_COL (f
, column
),
2177 CHAR_TO_PIXEL_ROW (f
, i
),
2178 FRAME_CURRENT_GLYPHS (f
)->glyphs
[i
] + column
,
2180 /* Highlight with mouse face if hl > 0. */
2184 /* If we turned the cursor off, turn it back on. */
2186 x_display_cursor (f
, 1);
2188 curs_x
= old_curs_x
;
2189 curs_y
= old_curs_y
;
2191 /* Change the mouse cursor according to the value of HL. */
2193 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2194 f
->output_data
.x
->cross_cursor
);
2196 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2197 f
->output_data
.x
->text_cursor
);
2200 /* Clear out the mouse-highlighted active region.
2201 Redraw it unhighlighted first. */
2204 clear_mouse_face (dpyinfo
)
2205 struct x_display_info
*dpyinfo
;
2207 if (! NILP (dpyinfo
->mouse_face_window
))
2208 show_mouse_face (dpyinfo
, 0);
2210 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
2211 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
2212 dpyinfo
->mouse_face_window
= Qnil
;
2215 static struct scroll_bar
*x_window_to_scroll_bar ();
2216 static void x_scroll_bar_report_motion ();
2218 /* Return the current position of the mouse.
2219 *fp should be a frame which indicates which display to ask about.
2221 If the mouse movement started in a scroll bar, set *fp, *bar_window,
2222 and *part to the frame, window, and scroll bar part that the mouse
2223 is over. Set *x and *y to the portion and whole of the mouse's
2224 position on the scroll bar.
2226 If the mouse movement started elsewhere, set *fp to the frame the
2227 mouse is on, *bar_window to nil, and *x and *y to the character cell
2230 Set *time to the server timestamp for the time at which the mouse
2231 was at this position.
2233 Don't store anything if we don't have a valid set of values to report.
2235 This clears the mouse_moved flag, so we can wait for the next mouse
2239 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
2242 Lisp_Object
*bar_window
;
2243 enum scroll_bar_part
*part
;
2245 unsigned long *time
;
2251 if (! NILP (last_mouse_scroll_bar
))
2252 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
2258 Window dummy_window
;
2261 Lisp_Object frame
, tail
;
2263 /* Clear the mouse-moved flag for every frame on this display. */
2264 FOR_EACH_FRAME (tail
, frame
)
2265 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
2266 XFRAME (frame
)->mouse_moved
= 0;
2268 last_mouse_scroll_bar
= Qnil
;
2270 /* Figure out which root window we're on. */
2271 XQueryPointer (FRAME_X_DISPLAY (*fp
),
2272 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
2274 /* The root window which contains the pointer. */
2277 /* Trash which we can't trust if the pointer is on
2278 a different screen. */
2281 /* The position on that root window. */
2284 /* More trash we can't trust. */
2287 /* Modifier keys and pointer buttons, about which
2289 (unsigned int *) &dummy
);
2291 /* Now we have a position on the root; find the innermost window
2292 containing the pointer. */
2296 int parent_x
, parent_y
;
2300 /* XTranslateCoordinates can get errors if the window
2301 structure is changing at the same time this function
2302 is running. So at least we must not crash from them. */
2304 x_catch_errors (FRAME_X_DISPLAY (*fp
));
2306 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
2307 && FRAME_LIVE_P (last_mouse_frame
))
2309 /* If mouse was grabbed on a frame, give coords for that frame
2310 even if the mouse is now outside it. */
2311 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
2313 /* From-window, to-window. */
2314 root
, FRAME_X_WINDOW (last_mouse_frame
),
2316 /* From-position, to-position. */
2317 root_x
, root_y
, &win_x
, &win_y
,
2321 f1
= last_mouse_frame
;
2327 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
2329 /* From-window, to-window. */
2332 /* From-position, to-position. */
2333 root_x
, root_y
, &win_x
, &win_y
,
2338 if (child
== None
|| child
== win
)
2346 /* Now we know that:
2347 win is the innermost window containing the pointer
2348 (XTC says it has no child containing the pointer),
2349 win_x and win_y are the pointer's position in it
2350 (XTC did this the last time through), and
2351 parent_x and parent_y are the pointer's position in win's parent.
2352 (They are what win_x and win_y were when win was child.
2353 If win is the root window, it has no parent, and
2354 parent_{x,y} are invalid, but that's okay, because we'll
2355 never use them in that case.) */
2357 /* Is win one of our frames? */
2358 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
2361 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
2364 x_uncatch_errors (FRAME_X_DISPLAY (*fp
));
2366 /* If not, is it one of our scroll bars? */
2369 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
2373 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2379 if (f1
== 0 && insist
)
2380 f1
= selected_frame
;
2384 int ignore1
, ignore2
;
2386 /* Ok, we found a frame. Store all the values. */
2388 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
2390 FRAME_X_DISPLAY_INFO (f1
)->grabbed
2396 XSETINT (*x
, win_x
);
2397 XSETINT (*y
, win_y
);
2398 *time
= last_mouse_movement_time
;
2406 /* Scroll bar support. */
2408 /* Given an X window ID, find the struct scroll_bar which manages it.
2409 This can be called in GC, so we have to make sure to strip off mark
2411 static struct scroll_bar
*
2412 x_window_to_scroll_bar (window_id
)
2415 Lisp_Object tail
, frame
;
2417 for (tail
= Vframe_list
;
2418 XGCTYPE (tail
) == Lisp_Cons
;
2419 tail
= XCONS (tail
)->cdr
)
2421 Lisp_Object frame
, bar
, condemned
;
2423 frame
= XCONS (tail
)->car
;
2424 /* All elements of Vframe_list should be frames. */
2425 if (! GC_FRAMEP (frame
))
2428 /* Scan this frame's scroll bar list for a scroll bar with the
2430 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
2431 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
2432 /* This trick allows us to search both the ordinary and
2433 condemned scroll bar lists with one loop. */
2434 ! GC_NILP (bar
) || (bar
= condemned
,
2437 bar
= XSCROLL_BAR (bar
)->next
)
2438 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
2439 return XSCROLL_BAR (bar
);
2445 /* Open a new X window to serve as a scroll bar, and return the
2446 scroll bar vector for it. */
2447 static struct scroll_bar
*
2448 x_scroll_bar_create (window
, top
, left
, width
, height
)
2449 struct window
*window
;
2450 int top
, left
, width
, height
;
2452 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2453 struct scroll_bar
*bar
2454 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
2459 XSetWindowAttributes a
;
2461 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
2462 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
2463 | ButtonMotionMask
| PointerMotionHintMask
2465 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
2467 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
2472 XtSetArg (al
[ac
], XtNx
, left
); ac
++;
2473 XtSetArg (al
[ac
], XtNy
, top
); ac
++;
2474 XtSetArg (al
[ac
], XtNwidth
, width
); ac
++;
2475 XtSetArg (al
[ac
], XtNheight
, height
); ac
++;
2476 XtSetArg (al
[ac
], XtNborderWidth
, 0); ac
++;
2477 sb_widget
= XtCreateManagedWidget ("box",
2479 f
->output_data
.x
->edit_widget
, al
, ac
);
2480 SET_SCROLL_BAR_X_WINDOW
2481 (bar
, sb_widget
->core
.window
);
2483 SET_SCROLL_BAR_X_WINDOW
2485 XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2487 /* Position and size of scroll bar. */
2488 left
, top
, width
, height
,
2490 /* Border width, depth, class, and visual. */
2491 0, CopyFromParent
, CopyFromParent
, CopyFromParent
,
2497 XSETWINDOW (bar
->window
, window
);
2498 XSETINT (bar
->top
, top
);
2499 XSETINT (bar
->left
, left
);
2500 XSETINT (bar
->width
, width
);
2501 XSETINT (bar
->height
, height
);
2502 XSETINT (bar
->start
, 0);
2503 XSETINT (bar
->end
, 0);
2504 bar
->dragging
= Qnil
;
2506 /* Add bar to its frame's list of scroll bars. */
2507 bar
->next
= FRAME_SCROLL_BARS (f
);
2509 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2510 if (! NILP (bar
->next
))
2511 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2513 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
2520 /* Draw BAR's handle in the proper position.
2521 If the handle is already drawn from START to END, don't bother
2522 redrawing it, unless REBUILD is non-zero; in that case, always
2523 redraw it. (REBUILD is handy for drawing the handle after expose
2526 Normally, we want to constrain the start and end of the handle to
2527 fit inside its rectangle, but if the user is dragging the scroll bar
2528 handle, we want to let them drag it down all the way, so that the
2529 bar's top is as far down as it goes; otherwise, there's no way to
2530 move to the very end of the buffer. */
2532 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
2533 struct scroll_bar
*bar
;
2537 int dragging
= ! NILP (bar
->dragging
);
2538 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2539 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2540 GC gc
= f
->output_data
.x
->normal_gc
;
2542 /* If the display is already accurate, do nothing. */
2544 && start
== XINT (bar
->start
)
2545 && end
== XINT (bar
->end
))
2551 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (XINT (bar
->width
));
2552 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2553 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2555 /* Make sure the values are reasonable, and try to preserve
2556 the distance between start and end. */
2558 int length
= end
- start
;
2562 else if (start
> top_range
)
2564 end
= start
+ length
;
2568 else if (end
> top_range
&& ! dragging
)
2572 /* Store the adjusted setting in the scroll bar. */
2573 XSETINT (bar
->start
, start
);
2574 XSETINT (bar
->end
, end
);
2576 /* Clip the end position, just for display. */
2577 if (end
> top_range
)
2580 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
2581 below top positions, to make sure the handle is always at least
2582 that many pixels tall. */
2583 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
2585 /* Draw the empty space above the handle. Note that we can't clear
2586 zero-height areas; that means "clear to end of window." */
2588 XClearArea (FRAME_X_DISPLAY (f
), w
,
2590 /* x, y, width, height, and exposures. */
2591 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2592 VERTICAL_SCROLL_BAR_TOP_BORDER
,
2593 inside_width
, start
,
2596 /* Draw the handle itself. */
2597 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
2599 /* x, y, width, height */
2600 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2601 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
2602 inside_width
, end
- start
);
2605 /* Draw the empty space below the handle. Note that we can't
2606 clear zero-height areas; that means "clear to end of window." */
2607 if (end
< inside_height
)
2608 XClearArea (FRAME_X_DISPLAY (f
), w
,
2610 /* x, y, width, height, and exposures. */
2611 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2612 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
2613 inside_width
, inside_height
- end
,
2621 /* Move a scroll bar around on the screen, to accommodate changing
2622 window configurations. */
2624 x_scroll_bar_move (bar
, top
, left
, width
, height
)
2625 struct scroll_bar
*bar
;
2626 int top
, left
, width
, height
;
2628 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2629 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2635 unsigned int mask
= 0;
2642 if (left
!= XINT (bar
->left
)) mask
|= CWX
;
2643 if (top
!= XINT (bar
->top
)) mask
|= CWY
;
2644 if (width
!= XINT (bar
->width
)) mask
|= CWWidth
;
2645 if (height
!= XINT (bar
->height
)) mask
|= CWHeight
;
2648 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
2652 XSETINT (bar
->left
, left
);
2653 XSETINT (bar
->top
, top
);
2654 XSETINT (bar
->width
, width
);
2655 XSETINT (bar
->height
, height
);
2660 /* Destroy the X window for BAR, and set its Emacs window's scroll bar
2663 x_scroll_bar_remove (bar
)
2664 struct scroll_bar
*bar
;
2666 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2670 /* Destroy the window. */
2671 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
2673 /* Disassociate this scroll bar from its window. */
2674 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
2679 /* Set the handle of the vertical scroll bar for WINDOW to indicate
2680 that we are displaying PORTION characters out of a total of WHOLE
2681 characters, starting at POSITION. If WINDOW has no scroll bar,
2684 XTset_vertical_scroll_bar (window
, portion
, whole
, position
)
2685 struct window
*window
;
2686 int portion
, whole
, position
;
2688 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2689 int top
= XINT (window
->top
);
2690 int left
= WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window
);
2691 int height
= WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window
);
2693 /* Where should this scroll bar be, pixelwise? */
2694 int pixel_top
= CHAR_TO_PIXEL_ROW (f
, top
);
2695 int pixel_left
= CHAR_TO_PIXEL_COL (f
, left
);
2697 = (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
2698 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
2699 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
2700 int pixel_height
= VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f
, height
);
2702 struct scroll_bar
*bar
;
2704 /* Does the scroll bar exist yet? */
2705 if (NILP (window
->vertical_scroll_bar
))
2706 bar
= x_scroll_bar_create (window
,
2707 pixel_top
, pixel_left
,
2708 pixel_width
, pixel_height
);
2711 /* It may just need to be moved and resized. */
2712 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2713 x_scroll_bar_move (bar
, pixel_top
, pixel_left
, pixel_width
, pixel_height
);
2716 /* Set the scroll bar's current state, unless we're currently being
2718 if (NILP (bar
->dragging
))
2720 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height
);
2723 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
2726 int start
= ((double) position
* top_range
) / whole
;
2727 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
2729 x_scroll_bar_set_handle (bar
, start
, end
, 0);
2733 XSETVECTOR (window
->vertical_scroll_bar
, bar
);
2737 /* The following three hooks are used when we're doing a thorough
2738 redisplay of the frame. We don't explicitly know which scroll bars
2739 are going to be deleted, because keeping track of when windows go
2740 away is a real pain - "Can you say set-window-configuration, boys
2741 and girls?" Instead, we just assert at the beginning of redisplay
2742 that *all* scroll bars are to be removed, and then save a scroll bar
2743 from the fiery pit when we actually redisplay its window. */
2745 /* Arrange for all scroll bars on FRAME to be removed at the next call
2746 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
2747 `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
2749 XTcondemn_scroll_bars (frame
)
2752 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
2753 while (! NILP (FRAME_SCROLL_BARS (frame
)))
2756 bar
= FRAME_SCROLL_BARS (frame
);
2757 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
2758 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
2759 XSCROLL_BAR (bar
)->prev
= Qnil
;
2760 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
2761 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
2762 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
2766 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
2767 Note that WINDOW isn't necessarily condemned at all. */
2769 XTredeem_scroll_bar (window
)
2770 struct window
*window
;
2772 struct scroll_bar
*bar
;
2774 /* We can't redeem this window's scroll bar if it doesn't have one. */
2775 if (NILP (window
->vertical_scroll_bar
))
2778 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2780 /* Unlink it from the condemned list. */
2782 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2784 if (NILP (bar
->prev
))
2786 /* If the prev pointer is nil, it must be the first in one of
2788 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
2789 /* It's not condemned. Everything's fine. */
2791 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
2792 window
->vertical_scroll_bar
))
2793 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
2795 /* If its prev pointer is nil, it must be at the front of
2796 one or the other! */
2800 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
2802 if (! NILP (bar
->next
))
2803 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
2805 bar
->next
= FRAME_SCROLL_BARS (f
);
2807 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2808 if (! NILP (bar
->next
))
2809 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2813 /* Remove all scroll bars on FRAME that haven't been saved since the
2814 last call to `*condemn_scroll_bars_hook'. */
2816 XTjudge_scroll_bars (f
)
2819 Lisp_Object bar
, next
;
2821 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
2823 /* Clear out the condemned list now so we won't try to process any
2824 more events on the hapless scroll bars. */
2825 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
2827 for (; ! NILP (bar
); bar
= next
)
2829 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
2831 x_scroll_bar_remove (b
);
2834 b
->next
= b
->prev
= Qnil
;
2837 /* Now there should be no references to the condemned scroll bars,
2838 and they should get garbage-collected. */
2842 /* Handle an Expose or GraphicsExpose event on a scroll bar.
2844 This may be called from a signal handler, so we have to ignore GC
2847 x_scroll_bar_expose (bar
, event
)
2848 struct scroll_bar
*bar
;
2851 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2852 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2853 GC gc
= f
->output_data
.x
->normal_gc
;
2857 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
2859 /* Draw a one-pixel border just inside the edges of the scroll bar. */
2860 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
2862 /* x, y, width, height */
2863 0, 0, XINT (bar
->width
) - 1, XINT (bar
->height
) - 1);
2868 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
2869 is set to something other than no_event, it is enqueued.
2871 This may be called from a signal handler, so we have to ignore GC
2874 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
2875 struct scroll_bar
*bar
;
2877 struct input_event
*emacs_event
;
2879 if (! GC_WINDOWP (bar
->window
))
2882 emacs_event
->kind
= scroll_bar_click
;
2883 emacs_event
->code
= event
->xbutton
.button
- Button1
;
2884 emacs_event
->modifiers
2885 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
2886 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
2887 event
->xbutton
.state
)
2888 | (event
->type
== ButtonRelease
2891 emacs_event
->frame_or_window
= bar
->window
;
2892 emacs_event
->timestamp
= event
->xbutton
.time
;
2895 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2897 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2898 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
2901 if (y
> top_range
) y
= top_range
;
2903 if (y
< XINT (bar
->start
))
2904 emacs_event
->part
= scroll_bar_above_handle
;
2905 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
2906 emacs_event
->part
= scroll_bar_handle
;
2908 emacs_event
->part
= scroll_bar_below_handle
;
2910 /* Just because the user has clicked on the handle doesn't mean
2911 they want to drag it. Lisp code needs to be able to decide
2912 whether or not we're dragging. */
2914 /* If the user has just clicked on the handle, record where they're
2916 if (event
->type
== ButtonPress
2917 && emacs_event
->part
== scroll_bar_handle
)
2918 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
2921 /* If the user has released the handle, set it to its final position. */
2922 if (event
->type
== ButtonRelease
2923 && ! NILP (bar
->dragging
))
2925 int new_start
= y
- XINT (bar
->dragging
);
2926 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2928 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2929 bar
->dragging
= Qnil
;
2932 /* Same deal here as the other #if 0. */
2934 /* Clicks on the handle are always reported as occurring at the top of
2936 if (emacs_event
->part
== scroll_bar_handle
)
2937 emacs_event
->x
= bar
->start
;
2939 XSETINT (emacs_event
->x
, y
);
2941 XSETINT (emacs_event
->x
, y
);
2944 XSETINT (emacs_event
->y
, top_range
);
2948 /* Handle some mouse motion while someone is dragging the scroll bar.
2950 This may be called from a signal handler, so we have to ignore GC
2953 x_scroll_bar_note_movement (bar
, event
)
2954 struct scroll_bar
*bar
;
2957 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
2959 last_mouse_movement_time
= event
->xmotion
.time
;
2962 XSETVECTOR (last_mouse_scroll_bar
, bar
);
2964 /* If we're dragging the bar, display it. */
2965 if (! GC_NILP (bar
->dragging
))
2967 /* Where should the handle be now? */
2968 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
2970 if (new_start
!= XINT (bar
->start
))
2972 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2974 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2979 /* Return information to the user about the current position of the mouse
2980 on the scroll bar. */
2982 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
2984 Lisp_Object
*bar_window
;
2985 enum scroll_bar_part
*part
;
2987 unsigned long *time
;
2989 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
2990 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2991 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2993 Window dummy_window
;
2995 unsigned int dummy_mask
;
2999 /* Get the mouse's position relative to the scroll bar window, and
3001 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
3003 /* Root, child, root x and root y. */
3004 &dummy_window
, &dummy_window
,
3005 &dummy_coord
, &dummy_coord
,
3007 /* Position relative to scroll bar. */
3010 /* Mouse buttons and modifier keys. */
3016 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
3018 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
3020 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
3022 if (! NILP (bar
->dragging
))
3023 win_y
-= XINT (bar
->dragging
);
3027 if (win_y
> top_range
)
3031 *bar_window
= bar
->window
;
3033 if (! NILP (bar
->dragging
))
3034 *part
= scroll_bar_handle
;
3035 else if (win_y
< XINT (bar
->start
))
3036 *part
= scroll_bar_above_handle
;
3037 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
3038 *part
= scroll_bar_handle
;
3040 *part
= scroll_bar_below_handle
;
3042 XSETINT (*x
, win_y
);
3043 XSETINT (*y
, top_range
);
3046 last_mouse_scroll_bar
= Qnil
;
3049 *time
= last_mouse_movement_time
;
3055 /* The screen has been cleared so we may have changed foreground or
3056 background colors, and the scroll bars may need to be redrawn.
3057 Clear out the scroll bars, and ask for expose events, so we can
3060 x_scroll_bar_clear (f
)
3065 /* We can have scroll bars even if this is 0,
3066 if we just turned off scroll bar mode.
3067 But in that case we should not clear them. */
3068 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3069 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
3070 bar
= XSCROLL_BAR (bar
)->next
)
3071 XClearArea (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
3075 /* This processes Expose events from the menubar specific X event
3076 loop in xmenu.c. This allows to redisplay the frame if necessary
3077 when handling menubar or popup items. */
3080 process_expose_from_menu (event
)
3084 struct x_display_info
*dpyinfo
;
3088 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
3089 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
3092 if (f
->async_visible
== 0)
3094 f
->async_visible
= 1;
3095 f
->async_iconified
= 0;
3096 SET_FRAME_GARBAGED (f
);
3100 dumprectangle (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
3101 event
.xexpose
.x
, event
.xexpose
.y
,
3102 event
.xexpose
.width
, event
.xexpose
.height
);
3107 struct scroll_bar
*bar
3108 = x_window_to_scroll_bar (event
.xexpose
.window
);
3111 x_scroll_bar_expose (bar
, &event
);
3117 /* Define a queue to save up SelectionRequest events for later handling. */
3119 struct selection_event_queue
3122 struct selection_event_queue
*next
;
3125 static struct selection_event_queue
*queue
;
3127 /* Nonzero means queue up certain events--don't process them yet. */
3128 static int x_queue_selection_requests
;
3130 /* Queue up an X event *EVENT, to be processed later. */
3133 x_queue_event (f
, event
)
3137 struct selection_event_queue
*queue_tmp
3138 = (struct selection_event_queue
*) malloc (sizeof (struct selection_event_queue
));
3140 if (queue_tmp
!= NULL
)
3142 queue_tmp
->event
= *event
;
3143 queue_tmp
->next
= queue
;
3148 /* Take all the queued events and put them back
3149 so that they get processed afresh. */
3152 x_unqueue_events (display
)
3155 while (queue
!= NULL
)
3157 struct selection_event_queue
*queue_tmp
= queue
;
3158 XPutBackEvent (display
, &queue_tmp
->event
);
3159 queue
= queue_tmp
->next
;
3160 free ((char *)queue_tmp
);
3164 /* Start queuing SelectionRequest events. */
3167 x_start_queuing_selection_requests (display
)
3170 x_queue_selection_requests
++;
3173 /* Stop queuing SelectionRequest events. */
3176 x_stop_queuing_selection_requests (display
)
3179 x_queue_selection_requests
--;
3180 x_unqueue_events (display
);
3183 /* The main X event-reading loop - XTread_socket. */
3185 /* Timestamp of enter window event. This is only used by XTread_socket,
3186 but we have to put it out here, since static variables within functions
3187 sometimes don't work. */
3188 static Time enter_timestamp
;
3190 /* This holds the state XLookupString needs to implement dead keys
3191 and other tricks known as "compose processing". _X Window System_
3192 says that a portable program can't use this, but Stephen Gildea assures
3193 me that letting the compiler initialize it to zeros will work okay.
3195 This must be defined outside of XTread_socket, for the same reasons
3196 given for enter_timestamp, above. */
3197 static XComposeStatus compose_status
;
3199 /* Record the last 100 characters stored
3200 to help debug the loss-of-chars-during-GC problem. */
3201 static int temp_index
;
3202 static short temp_buffer
[100];
3204 /* Set this to nonzero to fake an "X I/O error"
3205 on a particular display. */
3206 struct x_display_info
*XTread_socket_fake_io_error
;
3208 /* When we find no input here, we occasionally do a no-op command
3209 to verify that the X server is still running and we can still talk with it.
3210 We try all the open displays, one by one.
3211 This variable is used for cycling thru the displays. */
3212 static struct x_display_info
*next_noop_dpyinfo
;
3214 /* Read events coming from the X server.
3215 This routine is called by the SIGIO handler.
3216 We return as soon as there are no more events to be read.
3218 Events representing keys are stored in buffer BUFP,
3219 which can hold up to NUMCHARS characters.
3220 We return the number of characters stored into the buffer,
3221 thus pretending to be `read'.
3223 WAITP is nonzero if we should block until input arrives.
3224 EXPECTED is nonzero if the caller knows input is available. */
3227 XTread_socket (sd
, bufp
, numchars
, waitp
, expected
)
3229 register struct input_event
*bufp
;
3230 register int numchars
;
3237 int items_pending
; /* How many items are in the X queue. */
3240 int event_found
= 0;
3243 struct x_display_info
*dpyinfo
;
3245 Status status_return
;
3248 if (interrupt_input_blocked
)
3250 interrupt_input_pending
= 1;
3254 interrupt_input_pending
= 0;
3257 /* So people can tell when we have read the available input. */
3258 input_signal_count
++;
3261 abort (); /* Don't think this happens. */
3263 /* Find the display we are supposed to read input for.
3264 It's the one communicating on descriptor SD. */
3265 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
3267 #if 0 /* This ought to be unnecessary; let's verify it. */
3269 /* If available, Xlib uses FIOSNBIO to make the socket
3270 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
3271 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
3272 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
3273 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
3274 #endif /* ! defined (FIOSNBIO) */
3277 #if 0 /* This code can't be made to work, with multiple displays,
3278 and appears not to be used on any system any more.
3279 Also keyboard.c doesn't turn O_NDELAY on and off
3280 for X connections. */
3283 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
3285 extern int read_alarm_should_throw
;
3286 read_alarm_should_throw
= 1;
3287 XPeekEvent (dpyinfo
->display
, &event
);
3288 read_alarm_should_throw
= 0;
3290 #endif /* HAVE_SELECT */
3294 /* For debugging, this gives a way to fake an I/O error. */
3295 if (dpyinfo
== XTread_socket_fake_io_error
)
3297 XTread_socket_fake_io_error
= 0;
3298 x_io_error_quitter (dpyinfo
->display
);
3301 while (XPending (dpyinfo
->display
) != 0)
3303 #ifdef USE_X_TOOLKIT
3304 /* needed to raise Motif submenus */
3305 XtAppNextEvent (Xt_app_con
, &event
);
3307 XNextEvent (dpyinfo
->display
, &event
);
3315 if (event
.xclient
.message_type
3316 == dpyinfo
->Xatom_wm_protocols
3317 && event
.xclient
.format
== 32)
3319 if (event
.xclient
.data
.l
[0]
3320 == dpyinfo
->Xatom_wm_take_focus
)
3322 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
3323 /* Since we set WM_TAKE_FOCUS, we must call
3324 XSetInputFocus explicitly. But not if f is null,
3325 since that might be an event for a deleted frame. */
3327 /* Not quite sure this is needed -pd */
3329 XSetICFocus (FRAME_XIC (f
));
3332 XSetInputFocus (event
.xclient
.display
,
3333 event
.xclient
.window
,
3334 RevertToPointerRoot
,
3335 event
.xclient
.data
.l
[1]);
3336 /* Not certain about handling scroll bars here */
3338 else if (event
.xclient
.data
.l
[0]
3339 == dpyinfo
->Xatom_wm_save_yourself
)
3341 /* Save state modify the WM_COMMAND property to
3342 something which can reinstate us. This notifies
3343 the session manager, who's looking for such a
3344 PropertyNotify. Can restart processing when
3345 a keyboard or mouse event arrives. */
3348 f
= x_top_window_to_frame (dpyinfo
,
3349 event
.xclient
.window
);
3351 /* This is just so we only give real data once
3352 for a single Emacs process. */
3353 if (f
== selected_frame
)
3354 XSetCommand (FRAME_X_DISPLAY (f
),
3355 event
.xclient
.window
,
3356 initial_argv
, initial_argc
);
3358 XSetCommand (FRAME_X_DISPLAY (f
),
3359 event
.xclient
.window
,
3363 else if (event
.xclient
.data
.l
[0]
3364 == dpyinfo
->Xatom_wm_delete_window
)
3367 = x_any_window_to_frame (dpyinfo
,
3368 event
.xclient
.window
);
3375 bufp
->kind
= delete_window_event
;
3376 XSETFRAME (bufp
->frame_or_window
, f
);
3384 else if (event
.xclient
.message_type
3385 == dpyinfo
->Xatom_wm_configure_denied
)
3388 else if (event
.xclient
.message_type
3389 == dpyinfo
->Xatom_wm_window_moved
)
3393 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
3395 new_x
= event
.xclient
.data
.s
[0];
3396 new_y
= event
.xclient
.data
.s
[1];
3400 f
->output_data
.x
->left_pos
= new_x
;
3401 f
->output_data
.x
->top_pos
= new_y
;
3405 else if (event
.xclient
.message_type
3406 == dpyinfo
->Xatom_editres
)
3409 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
3410 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
3413 #endif /* HACK_EDITRES */
3417 case SelectionNotify
:
3418 #ifdef USE_X_TOOLKIT
3419 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
3421 #endif /* not USE_X_TOOLKIT */
3422 x_handle_selection_notify (&event
);
3425 case SelectionClear
: /* Someone has grabbed ownership. */
3426 #ifdef USE_X_TOOLKIT
3427 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
3429 #endif /* USE_X_TOOLKIT */
3431 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
3436 bufp
->kind
= selection_clear_event
;
3437 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3438 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3439 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3440 bufp
->frame_or_window
= Qnil
;
3448 case SelectionRequest
: /* Someone wants our selection. */
3449 #ifdef USE_X_TOOLKIT
3450 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
3452 #endif /* USE_X_TOOLKIT */
3453 if (x_queue_selection_requests
)
3454 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
3458 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
3463 bufp
->kind
= selection_request_event
;
3464 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3465 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
3466 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3467 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
3468 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
3469 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3470 bufp
->frame_or_window
= Qnil
;
3478 case PropertyNotify
:
3479 #ifdef USE_X_TOOLKIT
3480 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
3482 #endif /* not USE_X_TOOLKIT */
3483 x_handle_property_notify (&event
);
3486 case ReparentNotify
:
3487 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
3491 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
3492 x_real_positions (f
, &x
, &y
);
3493 f
->output_data
.x
->left_pos
= x
;
3494 f
->output_data
.x
->top_pos
= y
;
3499 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
3502 if (f
->async_visible
== 0)
3504 f
->async_visible
= 1;
3505 f
->async_iconified
= 0;
3506 SET_FRAME_GARBAGED (f
);
3509 dumprectangle (x_window_to_frame (dpyinfo
,
3510 event
.xexpose
.window
),
3511 event
.xexpose
.x
, event
.xexpose
.y
,
3512 event
.xexpose
.width
, event
.xexpose
.height
);
3516 struct scroll_bar
*bar
3517 = x_window_to_scroll_bar (event
.xexpose
.window
);
3520 x_scroll_bar_expose (bar
, &event
);
3521 #ifdef USE_X_TOOLKIT
3524 #endif /* USE_X_TOOLKIT */
3528 case GraphicsExpose
: /* This occurs when an XCopyArea's
3529 source area was obscured or not
3531 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
3535 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
3536 event
.xgraphicsexpose
.width
,
3537 event
.xgraphicsexpose
.height
);
3539 #ifdef USE_X_TOOLKIT
3542 #endif /* USE_X_TOOLKIT */
3545 case NoExpose
: /* This occurs when an XCopyArea's
3546 source area was completely
3551 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
3552 if (f
) /* F may no longer exist if
3553 the frame was deleted. */
3555 /* While a frame is unmapped, display generation is
3556 disabled; you don't want to spend time updating a
3557 display that won't ever be seen. */
3558 f
->async_visible
= 0;
3559 /* We can't distinguish, from the event, whether the window
3560 has become iconified or invisible. So assume, if it
3561 was previously visible, than now it is iconified.
3562 We depend on x_make_frame_invisible to mark it invisible. */
3563 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
3564 f
->async_iconified
= 1;
3566 bufp
->kind
= iconify_event
;
3567 XSETFRAME (bufp
->frame_or_window
, f
);
3575 /* We use x_top_window_to_frame because map events can come
3576 for subwindows and they don't mean that the frame is visible. */
3577 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
3580 f
->async_visible
= 1;
3581 f
->async_iconified
= 0;
3583 /* wait_reading_process_input will notice this and update
3584 the frame's display structures. */
3585 SET_FRAME_GARBAGED (f
);
3589 bufp
->kind
= deiconify_event
;
3590 XSETFRAME (bufp
->frame_or_window
, f
);
3595 else if (! NILP(Vframe_list
)
3596 && ! NILP (XCONS (Vframe_list
)->cdr
))
3597 /* Force a redisplay sooner or later
3598 to update the frame titles
3599 in case this is the second frame. */
3600 record_asynch_buffer_change ();
3604 /* Turn off processing if we become fully obscured. */
3605 case VisibilityNotify
:
3609 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
3613 KeySym keysym
, orig_keysym
;
3614 /* al%imercury@uunet.uu.net says that making this 81 instead of
3615 80 fixed a bug whereby meta chars made his Emacs hang. */
3616 unsigned char copy_buffer
[81];
3620 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
3621 extra_keyboard_modifiers
);
3622 modifiers
= event
.xkey
.state
;
3624 /* This will have to go some day... */
3626 /* make_lispy_event turns chars into control chars.
3627 Don't do it here because XLookupString is too eager. */
3628 event
.xkey
.state
&= ~ControlMask
;
3629 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
3630 | dpyinfo
->super_mod_mask
3631 | dpyinfo
->hyper_mod_mask
3632 | dpyinfo
->alt_mod_mask
);
3637 /* The necessity of the following line took me
3638 a full work-day to decipher from the docs!! */
3639 if (XFilterEvent (&event
, None
))
3641 nbytes
= XmbLookupString (FRAME_XIC (f
),
3642 &event
.xkey
, copy_buffer
,
3647 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
3648 80, &keysym
, &compose_status
);
3650 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
3651 80, &keysym
, &compose_status
);
3654 orig_keysym
= keysym
;
3658 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
3659 || keysym
== XK_Delete
3660 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
3661 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
3663 /* This recognizes the "extended function keys".
3664 It seems there's no cleaner way.
3665 Test IsModifierKey to avoid handling mode_switch
3667 || ((unsigned) (keysym
) >= XK_Select
3668 && (unsigned)(keysym
) < XK_KP_Space
)
3670 #ifdef XK_dead_circumflex
3671 || orig_keysym
== XK_dead_circumflex
3673 #ifdef XK_dead_grave
3674 || orig_keysym
== XK_dead_grave
3676 #ifdef XK_dead_tilde
3677 || orig_keysym
== XK_dead_tilde
3679 #ifdef XK_dead_diaeresis
3680 || orig_keysym
== XK_dead_diaeresis
3682 #ifdef XK_dead_macron
3683 || orig_keysym
== XK_dead_macron
3685 #ifdef XK_dead_degree
3686 || orig_keysym
== XK_dead_degree
3688 #ifdef XK_dead_acute
3689 || orig_keysym
== XK_dead_acute
3691 #ifdef XK_dead_cedilla
3692 || orig_keysym
== XK_dead_cedilla
3694 #ifdef XK_dead_breve
3695 || orig_keysym
== XK_dead_breve
3697 #ifdef XK_dead_ogonek
3698 || orig_keysym
== XK_dead_ogonek
3700 #ifdef XK_dead_caron
3701 || orig_keysym
== XK_dead_caron
3703 #ifdef XK_dead_doubleacute
3704 || orig_keysym
== XK_dead_doubleacute
3706 #ifdef XK_dead_abovedot
3707 || orig_keysym
== XK_dead_abovedot
3709 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
3710 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
3711 /* Any "vendor-specific" key is ok. */
3712 || (orig_keysym
& (1 << 28)))
3713 && ! (IsModifierKey (orig_keysym
)
3715 #ifdef XK_Mode_switch
3716 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
3719 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
3721 #endif /* not HAVE_X11R5 */
3724 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3726 temp_buffer
[temp_index
++] = keysym
;
3727 bufp
->kind
= non_ascii_keystroke
;
3728 bufp
->code
= keysym
;
3729 XSETFRAME (bufp
->frame_or_window
, f
);
3731 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3733 bufp
->timestamp
= event
.xkey
.time
;
3738 else if (numchars
> nbytes
)
3742 for (i
= 0; i
< nbytes
; i
++)
3744 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3746 temp_buffer
[temp_index
++] = copy_buffer
[i
];
3747 bufp
->kind
= ascii_keystroke
;
3748 bufp
->code
= copy_buffer
[i
];
3749 XSETFRAME (bufp
->frame_or_window
, f
);
3751 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3753 bufp
->timestamp
= event
.xkey
.time
;
3768 /* Here's a possible interpretation of the whole
3769 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If you get a
3770 FocusIn event, you have to get a FocusOut event before you
3771 relinquish the focus. If you haven't received a FocusIn event,
3772 then a mere LeaveNotify is enough to free you. */
3775 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
3777 if (event
.xcrossing
.focus
) /* Entered Window */
3779 /* Avoid nasty pop/raise loops. */
3780 if (f
&& (!(f
->auto_raise
)
3782 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
3784 x_new_focus_frame (dpyinfo
, f
);
3785 enter_timestamp
= event
.xcrossing
.time
;
3788 else if (f
== dpyinfo
->x_focus_frame
)
3789 x_new_focus_frame (dpyinfo
, 0);
3790 /* EnterNotify counts as mouse movement,
3791 so update things that depend on mouse position. */
3793 note_mouse_movement (f
, &event
.xmotion
);
3797 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
3798 if (event
.xfocus
.detail
!= NotifyPointer
)
3799 dpyinfo
->x_focus_event_frame
= f
;
3801 x_new_focus_frame (dpyinfo
, f
);
3804 if (f
&& FRAME_XIC (f
))
3805 XSetICFocus (FRAME_XIC (f
));
3811 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
3814 if (f
== dpyinfo
->mouse_face_mouse_frame
)
3815 /* If we move outside the frame,
3816 then we're certainly no longer on any text in the frame. */
3817 clear_mouse_face (dpyinfo
);
3819 if (event
.xcrossing
.focus
)
3820 x_mouse_leave (dpyinfo
);
3823 if (f
== dpyinfo
->x_focus_event_frame
)
3824 dpyinfo
->x_focus_event_frame
= 0;
3825 if (f
== dpyinfo
->x_focus_frame
)
3826 x_new_focus_frame (dpyinfo
, 0);
3832 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
3833 if (event
.xfocus
.detail
!= NotifyPointer
3834 && f
== dpyinfo
->x_focus_event_frame
)
3835 dpyinfo
->x_focus_event_frame
= 0;
3836 if (f
&& f
== dpyinfo
->x_focus_frame
)
3837 x_new_focus_frame (dpyinfo
, 0);
3840 if (f
&& FRAME_XIC (f
))
3841 XUnsetICFocus (FRAME_XIC (f
));
3848 if (dpyinfo
->grabbed
&& last_mouse_frame
3849 && FRAME_LIVE_P (last_mouse_frame
))
3850 f
= last_mouse_frame
;
3852 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
3854 note_mouse_movement (f
, &event
.xmotion
);
3857 struct scroll_bar
*bar
3858 = x_window_to_scroll_bar (event
.xmotion
.window
);
3861 x_scroll_bar_note_movement (bar
, &event
);
3863 /* If we move outside the frame,
3864 then we're certainly no longer on any text in the frame. */
3865 clear_mouse_face (dpyinfo
);
3870 case ConfigureNotify
:
3871 f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
3873 #ifdef USE_X_TOOLKIT
3874 && (event
.xconfigure
.window
== XtWindow (f
->output_data
.x
->widget
))
3878 #ifndef USE_X_TOOLKIT
3879 /* In the toolkit version, change_frame_size
3880 is called by the code that handles resizing
3881 of the EmacsFrame widget. */
3883 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
3884 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
3886 /* Even if the number of character rows and columns has
3887 not changed, the font size may have changed, so we need
3888 to check the pixel dimensions as well. */
3889 if (columns
!= f
->width
3890 || rows
!= f
->height
3891 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
3892 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
3894 change_frame_size (f
, rows
, columns
, 0, 1);
3895 SET_FRAME_GARBAGED (f
);
3899 /* Formerly, in the USE_X_TOOLKIT version,
3900 we did not test send_event here. */
3902 #ifndef USE_X_TOOLKIT
3903 && ! event
.xconfigure
.send_event
3910 /* Find the position of the outside upper-left corner of
3911 the window, in the root coordinate system. Don't
3912 refer to the parent window here; we may be processing
3913 this event after the window manager has changed our
3914 parent, but before we have reached the ReparentNotify. */
3915 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3917 /* From-window, to-window. */
3918 event
.xconfigure
.window
,
3919 FRAME_X_DISPLAY_INFO (f
)->root_window
,
3921 /* From-position, to-position. */
3922 -event
.xconfigure
.border_width
,
3923 -event
.xconfigure
.border_width
,
3928 event
.xconfigure
.x
= win_x
;
3929 event
.xconfigure
.y
= win_y
;
3932 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
3933 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
3934 f
->output_data
.x
->left_pos
= event
.xconfigure
.x
;
3935 f
->output_data
.x
->top_pos
= event
.xconfigure
.y
;
3937 /* What we have now is the position of Emacs's own window.
3938 Convert that to the position of the window manager window. */
3941 x_real_positions (f
, &x
, &y
);
3942 f
->output_data
.x
->left_pos
= x
;
3943 f
->output_data
.x
->top_pos
= y
;
3944 /* Formerly we did not do this in the USE_X_TOOLKIT
3945 version. Let's try making them the same. */
3946 /* #ifndef USE_X_TOOLKIT */
3947 if (y
!= event
.xconfigure
.y
)
3949 /* Since the WM decorations come below top_pos now,
3950 we must put them below top_pos in the future. */
3951 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
3952 x_wm_set_size_hint (f
, (long) 0, 0);
3962 /* If we decide we want to generate an event to be seen
3963 by the rest of Emacs, we put it here. */
3964 struct input_event emacs_event
;
3965 emacs_event
.kind
= no_event
;
3967 bzero (&compose_status
, sizeof (compose_status
));
3969 if (dpyinfo
->grabbed
&& last_mouse_frame
3970 && FRAME_LIVE_P (last_mouse_frame
))
3971 f
= last_mouse_frame
;
3973 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
3977 if (!dpyinfo
->x_focus_frame
|| f
== dpyinfo
->x_focus_frame
)
3978 construct_mouse_click (&emacs_event
, &event
, f
);
3982 struct scroll_bar
*bar
3983 = x_window_to_scroll_bar (event
.xbutton
.window
);
3986 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
3989 if (event
.type
== ButtonPress
)
3991 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
3992 last_mouse_frame
= f
;
3996 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
3999 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
4001 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
4007 #ifdef USE_X_TOOLKIT
4008 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
4009 /* For a down-event in the menu bar,
4010 don't pass it to Xt right now.
4011 Instead, save it away
4012 and we will pass it to Xt from kbd_buffer_get_event.
4013 That way, we can run some Lisp code first. */
4014 if (f
&& event
.type
== ButtonPress
4015 /* Verify the event is really within the menu bar
4016 and not just sent to it due to grabbing. */
4017 && event
.xbutton
.x
>= 0
4018 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
4019 && event
.xbutton
.y
>= 0
4020 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
4021 && event
.xbutton
.same_screen
)
4023 if (f
->output_data
.x
->saved_button_event
== 0)
4024 f
->output_data
.x
->saved_button_event
4025 = (XButtonEvent
*) xmalloc (sizeof (XButtonEvent
));
4026 bcopy (&event
, f
->output_data
.x
->saved_button_event
,
4027 sizeof (XButtonEvent
));
4030 bufp
->kind
= menu_bar_activate_event
;
4031 XSETFRAME (bufp
->frame_or_window
, f
);
4039 #endif /* USE_X_TOOLKIT */
4043 case CirculateNotify
:
4045 case CirculateRequest
:
4049 /* Someone has changed the keyboard mapping - update the
4051 switch (event
.xmapping
.request
)
4053 case MappingModifier
:
4054 x_find_modifier_meanings (dpyinfo
);
4055 /* This is meant to fall through. */
4056 case MappingKeyboard
:
4057 XRefreshKeyboardMapping (&event
.xmapping
);
4063 #ifdef USE_X_TOOLKIT
4065 XtDispatchEvent (&event
);
4067 #endif /* USE_X_TOOLKIT */
4073 /* On some systems, an X bug causes Emacs to get no more events
4074 when the window is destroyed. Detect that. (1994.) */
4077 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
4078 One XNOOP in 100 loops will make Emacs terminate.
4079 B. Bretthauer, 1994 */
4081 if (x_noop_count
>= 100)
4085 if (next_noop_dpyinfo
== 0)
4086 next_noop_dpyinfo
= x_display_list
;
4088 XNoOp (next_noop_dpyinfo
->display
);
4090 /* Each time we get here, cycle through the displays now open. */
4091 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
4095 /* If the focus was just given to an autoraising frame,
4097 /* ??? This ought to be able to handle more than one such frame. */
4098 if (pending_autoraise_frame
)
4100 x_raise_frame (pending_autoraise_frame
);
4101 pending_autoraise_frame
= 0;
4108 /* Drawing the cursor. */
4111 /* Draw a hollow box cursor on frame F at X, Y.
4112 Don't change the inside of the box. */
4115 x_draw_box (f
, x
, y
)
4119 int left
= CHAR_TO_PIXEL_COL (f
, x
);
4120 int top
= CHAR_TO_PIXEL_ROW (f
, y
);
4121 int width
= FONT_WIDTH (f
->output_data
.x
->font
);
4122 int height
= f
->output_data
.x
->line_height
;
4124 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4125 f
->output_data
.x
->cursor_gc
,
4126 left
, top
, width
- 1, height
- 1);
4129 /* Clear the cursor of frame F to background color,
4130 and mark the cursor as not shown.
4131 This is used when the text where the cursor is
4132 is about to be rewritten. */
4140 if (! FRAME_VISIBLE_P (f
)
4141 || f
->phys_cursor_x
< 0)
4144 x_display_cursor (f
, 0);
4145 f
->phys_cursor_x
= -1;
4148 /* Redraw the glyph at ROW, COLUMN on frame F, in the style
4149 HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
4153 x_draw_single_glyph (f
, row
, column
, glyph
, highlight
)
4160 CHAR_TO_PIXEL_COL (f
, column
),
4161 CHAR_TO_PIXEL_ROW (f
, row
),
4162 &glyph
, 1, highlight
, 0);
4166 x_display_bar_cursor (f
, on
, x
, y
)
4171 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4173 /* This is pointless on invisible frames, and dangerous on garbaged
4174 frames; in the latter case, the frame may be in the midst of
4175 changing its size, and x and y may be off the frame. */
4176 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4179 if (! on
&& f
->phys_cursor_x
< 0)
4182 /* If there is anything wrong with the current cursor state, remove it. */
4183 if (f
->phys_cursor_x
>= 0
4185 || f
->phys_cursor_x
!= x
4186 || f
->phys_cursor_y
!= y
4187 || f
->output_data
.x
->current_cursor
!= bar_cursor
))
4189 /* Erase the cursor by redrawing the character underneath it. */
4190 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4191 f
->phys_cursor_glyph
,
4192 current_glyphs
->highlight
[f
->phys_cursor_y
]);
4193 f
->phys_cursor_x
= -1;
4196 /* If we now need a cursor in the new place or in the new form, do it so. */
4198 && (f
->phys_cursor_x
< 0
4199 || (f
->output_data
.x
->current_cursor
!= bar_cursor
)))
4201 f
->phys_cursor_glyph
4202 = ((current_glyphs
->enable
[y
]
4203 && x
< current_glyphs
->used
[y
])
4204 ? current_glyphs
->glyphs
[y
][x
]
4206 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4207 f
->output_data
.x
->cursor_gc
,
4208 CHAR_TO_PIXEL_COL (f
, x
),
4209 CHAR_TO_PIXEL_ROW (f
, y
),
4210 max (f
->output_data
.x
->cursor_width
, 1),
4211 f
->output_data
.x
->line_height
);
4213 f
->phys_cursor_x
= x
;
4214 f
->phys_cursor_y
= y
;
4216 f
->output_data
.x
->current_cursor
= bar_cursor
;
4219 if (updating_frame
!= f
)
4220 XFlush (FRAME_X_DISPLAY (f
));
4224 /* Turn the displayed cursor of frame F on or off according to ON.
4225 If ON is nonzero, where to put the cursor is specified by X and Y. */
4228 x_display_box_cursor (f
, on
, x
, y
)
4233 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4235 /* This is pointless on invisible frames, and dangerous on garbaged
4236 frames; in the latter case, the frame may be in the midst of
4237 changing its size, and x and y may be off the frame. */
4238 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4241 /* If cursor is off and we want it off, return quickly. */
4242 if (!on
&& f
->phys_cursor_x
< 0)
4245 /* If cursor is currently being shown and we don't want it to be
4246 or it is in the wrong place,
4247 or we want a hollow box and it's not so, (pout!)
4249 if (f
->phys_cursor_x
>= 0
4251 || f
->phys_cursor_x
!= x
4252 || f
->phys_cursor_y
!= y
4253 || (f
->output_data
.x
->current_cursor
!= hollow_box_cursor
4254 && (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
))))
4256 int mouse_face_here
= 0;
4257 struct frame_glyphs
*active_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4259 /* If the cursor is in the mouse face area, redisplay that when
4260 we clear the cursor. */
4261 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
4263 (f
->phys_cursor_y
> FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
4264 || (f
->phys_cursor_y
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
4265 && f
->phys_cursor_x
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
))
4267 (f
->phys_cursor_y
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
4268 || (f
->phys_cursor_y
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
4269 && f
->phys_cursor_x
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
))
4270 /* Don't redraw the cursor's spot in mouse face
4271 if it is at the end of a line (on a newline).
4272 The cursor appears there, but mouse highlighting does not. */
4273 && active_glyphs
->used
[f
->phys_cursor_y
] > f
->phys_cursor_x
)
4274 mouse_face_here
= 1;
4276 /* If the font is not as tall as a whole line,
4277 we must explicitly clear the line's whole height. */
4278 if (FONT_HEIGHT (f
->output_data
.x
->font
) != f
->output_data
.x
->line_height
)
4279 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4280 CHAR_TO_PIXEL_COL (f
, f
->phys_cursor_x
),
4281 CHAR_TO_PIXEL_ROW (f
, f
->phys_cursor_y
),
4282 FONT_WIDTH (f
->output_data
.x
->font
),
4283 f
->output_data
.x
->line_height
, False
);
4284 /* Erase the cursor by redrawing the character underneath it. */
4285 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4286 f
->phys_cursor_glyph
,
4289 : current_glyphs
->highlight
[f
->phys_cursor_y
]));
4290 f
->phys_cursor_x
= -1;
4293 /* If we want to show a cursor,
4294 or we want a box cursor and it's not so,
4295 write it in the right place. */
4297 && (f
->phys_cursor_x
< 0
4298 || (f
->output_data
.x
->current_cursor
!= filled_box_cursor
4299 && f
== FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)))
4301 f
->phys_cursor_glyph
4302 = ((current_glyphs
->enable
[y
]
4303 && x
< current_glyphs
->used
[y
])
4304 ? current_glyphs
->glyphs
[y
][x
]
4306 if (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
4308 x_draw_box (f
, x
, y
);
4309 f
->output_data
.x
->current_cursor
= hollow_box_cursor
;
4313 x_draw_single_glyph (f
, y
, x
,
4314 f
->phys_cursor_glyph
, 2);
4315 f
->output_data
.x
->current_cursor
= filled_box_cursor
;
4318 f
->phys_cursor_x
= x
;
4319 f
->phys_cursor_y
= y
;
4322 if (updating_frame
!= f
)
4323 XFlush (FRAME_X_DISPLAY (f
));
4326 /* Display the cursor on frame F, or clear it, according to ON.
4327 Use the position specified by curs_x and curs_y
4328 if we are doing an update of frame F now.
4329 Otherwise use the position in the FRAME_CURSOR_X and FRAME_CURSOR_Y fields
4332 x_display_cursor (f
, on
)
4338 /* If we're not updating, then don't change the physical cursor
4339 position. Just change (if appropriate) the style of display. */
4340 if (f
!= updating_frame
)
4342 curs_x
= FRAME_CURSOR_X (f
);
4343 curs_y
= FRAME_CURSOR_Y (f
);
4346 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4347 x_display_box_cursor (f
, on
, curs_x
, curs_y
);
4348 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4349 x_display_bar_cursor (f
, on
, curs_x
, curs_y
);
4351 /* Those are the only two we have implemented! */
4357 /* Display the cursor on frame F, or clear it, according to ON.
4358 Don't change the cursor's position. */
4360 x_update_cursor (f
, on
)
4364 /* If we don't have any previous cursor position to use,
4365 leave the cursor off. */
4366 if (f
->phys_cursor_x
< 0)
4371 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4372 x_display_box_cursor (f
, on
, f
->phys_cursor_x
, f
->phys_cursor_y
);
4373 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4374 x_display_bar_cursor (f
, on
, f
->phys_cursor_x
, f
->phys_cursor_y
);
4376 /* Those are the only two we have implemented! */
4384 /* Refresh bitmap kitchen sink icon for frame F
4385 when we get an expose event for it. */
4390 /* Normally, the window manager handles this function. */
4393 /* Make the x-window of frame F use the gnu icon bitmap. */
4396 x_bitmap_icon (f
, file
)
4400 int mask
, bitmap_id
;
4403 if (FRAME_X_WINDOW (f
) == 0)
4406 /* Free up our existing icon bitmap if any. */
4407 if (f
->output_data
.x
->icon_bitmap
> 0)
4408 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
4409 f
->output_data
.x
->icon_bitmap
= 0;
4412 bitmap_id
= x_create_bitmap_from_file (f
, file
);
4415 /* Create the GNU bitmap if necessary. */
4416 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
4417 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
4418 = x_create_bitmap_from_data (f
, gnu_bits
,
4419 gnu_width
, gnu_height
);
4421 /* The first time we create the GNU bitmap,
4422 this increments the refcount one extra time.
4423 As a result, the GNU bitmap is never freed.
4424 That way, we don't have to worry about allocating it again. */
4425 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
4427 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
4430 x_wm_set_icon_pixmap (f
, bitmap_id
);
4431 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
4437 /* Make the x-window of frame F use a rectangle with text.
4438 Use ICON_NAME as the text. */
4441 x_text_icon (f
, icon_name
)
4445 if (FRAME_X_WINDOW (f
) == 0)
4451 text
.value
= (unsigned char *) icon_name
;
4452 text
.encoding
= XA_STRING
;
4454 text
.nitems
= strlen (icon_name
);
4455 #ifdef USE_X_TOOLKIT
4456 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
4458 #else /* not USE_X_TOOLKIT */
4459 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
4460 #endif /* not USE_X_TOOLKIT */
4462 #else /* not HAVE_X11R4 */
4463 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
4464 #endif /* not HAVE_X11R4 */
4466 if (f
->output_data
.x
->icon_bitmap
> 0)
4467 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
4468 f
->output_data
.x
->icon_bitmap
= 0;
4469 x_wm_set_icon_pixmap (f
, 0);
4474 /* Handling X errors. */
4476 /* Handle the loss of connection to display DISPLAY. */
4479 x_connection_closed (display
, error_message
)
4481 char *error_message
;
4483 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
4484 Lisp_Object frame
, tail
;
4486 /* Indicate that this display is dead. */
4488 dpyinfo
->display
= 0;
4490 /* First delete frames whose minibuffers are on frames
4491 that are on the dead display. */
4492 FOR_EACH_FRAME (tail
, frame
)
4494 Lisp_Object minibuf_frame
;
4496 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
4497 if (FRAME_X_P (XFRAME (frame
))
4498 && FRAME_X_P (XFRAME (minibuf_frame
))
4499 && ! EQ (frame
, minibuf_frame
)
4500 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
4501 Fdelete_frame (frame
, Qt
);
4504 /* Now delete all remaining frames on the dead display.
4505 We are now sure none of these is used as the minibuffer
4506 for another frame that we need to delete. */
4507 FOR_EACH_FRAME (tail
, frame
)
4508 if (FRAME_X_P (XFRAME (frame
))
4509 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
4511 /* Set this to t so that Fdelete_frame won't get confused
4512 trying to find a replacement. */
4513 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
4514 Fdelete_frame (frame
, Qt
);
4518 x_delete_display (dpyinfo
);
4520 if (x_display_list
== 0)
4522 fprintf (stderr
, "%s\n", error_message
);
4523 shut_down_emacs (0, 0, Qnil
);
4527 /* Ordinary stack unwind doesn't deal with these. */
4529 sigunblock (sigmask (SIGIO
));
4531 sigunblock (sigmask (SIGALRM
));
4532 TOTALLY_UNBLOCK_INPUT
;
4534 clear_waiting_for_input ();
4535 error ("%s", error_message
);
4538 /* This is the usual handler for X protocol errors.
4539 It kills all frames on the display that we got the error for.
4540 If that was the only one, it prints an error message and kills Emacs. */
4543 x_error_quitter (display
, error
)
4547 char buf
[256], buf1
[356];
4549 /* Note that there is no real way portable across R3/R4 to get the
4550 original error handler. */
4552 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
4553 sprintf (buf1
, "X protocol error: %s on protocol request %d",
4554 buf
, error
->request_code
);
4555 x_connection_closed (display
, buf1
);
4558 /* This is the handler for X IO errors, always.
4559 It kills all frames on the display that we lost touch with.
4560 If that was the only one, it prints an error message and kills Emacs. */
4563 x_io_error_quitter (display
)
4568 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
4569 x_connection_closed (display
, buf
);
4572 /* Handle SIGPIPE, which can happen when the connection to a server
4573 simply goes away. SIGPIPE is handled by x_connection_signal.
4574 Don't need to do anything, because the write which caused the
4575 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
4576 which will do the appropriate cleanup for us. */
4579 x_connection_signal (signalnum
) /* If we don't have an argument, */
4580 int signalnum
; /* some compilers complain in signal calls. */
4583 /* USG systems forget handlers when they are used;
4584 must reestablish each time */
4585 signal (signalnum
, x_connection_signal
);
4589 /* A buffer for storing X error messages. */
4590 static char *x_caught_error_message
;
4591 #define X_CAUGHT_ERROR_MESSAGE_SIZE 200
4593 /* An X error handler which stores the error message in
4594 x_caught_error_message. This is what's installed when
4595 x_catch_errors is in effect. */
4598 x_error_catcher (display
, error
)
4602 XGetErrorText (display
, error
->error_code
,
4603 x_caught_error_message
, X_CAUGHT_ERROR_MESSAGE_SIZE
);
4607 /* Begin trapping X errors for display DPY. Actually we trap X errors
4608 for all displays, but DPY should be the display you are actually
4611 After calling this function, X protocol errors no longer cause
4612 Emacs to exit; instead, they are recorded in x_cfc_error_message.
4614 Calling x_check_errors signals an Emacs error if an X error has
4615 occurred since the last call to x_catch_errors or x_check_errors.
4617 Calling x_uncatch_errors resumes the normal error handling. */
4619 void x_catch_errors (), x_check_errors (), x_uncatch_errors ();
4622 x_catch_errors (dpy
)
4625 /* Make sure any errors from previous requests have been dealt with. */
4628 /* Set up the error buffer. */
4629 x_caught_error_message
4630 = (char*) xmalloc (X_CAUGHT_ERROR_MESSAGE_SIZE
);
4631 x_caught_error_message
[0] = '\0';
4633 /* Install our little error handler. */
4634 XSetErrorHandler (x_error_catcher
);
4637 /* If any X protocol errors have arrived since the last call to
4638 x_catch_errors or x_check_errors, signal an Emacs error using
4639 sprintf (a buffer, FORMAT, the x error message text) as the text. */
4642 x_check_errors (dpy
, format
)
4646 /* Make sure to catch any errors incurred so far. */
4649 if (x_caught_error_message
[0])
4651 char buf
[X_CAUGHT_ERROR_MESSAGE_SIZE
+ 56];
4653 sprintf (buf
, format
, x_caught_error_message
);
4654 x_uncatch_errors (dpy
);
4659 /* Nonzero if we had any X protocol errors since we did x_catch_errors. */
4662 x_had_errors_p (dpy
)
4665 /* Make sure to catch any errors incurred so far. */
4668 return x_caught_error_message
[0] != 0;
4671 /* Stop catching X protocol errors and let them make Emacs die. */
4674 x_uncatch_errors (dpy
)
4677 xfree (x_caught_error_message
);
4678 x_caught_error_message
= 0;
4679 XSetErrorHandler (x_error_quitter
);
4683 static unsigned int x_wire_count
;
4686 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
4691 /* Changing the font of the frame. */
4693 /* Give frame F the font named FONTNAME as its default font, and
4694 return the full name of that font. FONTNAME may be a wildcard
4695 pattern; in that case, we choose some font that fits the pattern.
4696 The return value shows which font we chose. */
4699 x_new_font (f
, fontname
)
4701 register char *fontname
;
4704 int n_matching_fonts
;
4705 XFontStruct
*font_info
;
4708 /* Get a list of all the fonts that match this name. Once we
4709 have a list of matching fonts, we compare them against the fonts
4710 we already have by comparing font ids. */
4711 font_names
= (char **) XListFonts (FRAME_X_DISPLAY (f
), fontname
,
4712 1024, &n_matching_fonts
);
4713 /* Apparently it doesn't set n_matching_fonts to zero when it can't
4714 find any matches; font_names == 0 is the only clue. */
4716 n_matching_fonts
= 0;
4718 /* Don't just give up if n_matching_fonts is 0.
4719 Apparently there's a bug on Suns: XListFontsWithInfo can
4720 fail to find a font, but XLoadQueryFont may still find it. */
4722 /* See if we've already loaded a matching font. */
4723 already_loaded
= -1;
4724 if (n_matching_fonts
!= 0)
4728 for (i
= 0; i
< FRAME_X_DISPLAY_INFO (f
)->n_fonts
; i
++)
4729 for (j
= 0; j
< n_matching_fonts
; j
++)
4730 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].name
, font_names
[j
])
4731 || !strcmp (FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].full_name
, font_names
[j
]))
4734 fontname
= FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].full_name
;
4740 /* If we have, just return it from the table. */
4741 if (already_loaded
>= 0)
4742 f
->output_data
.x
->font
= FRAME_X_DISPLAY_INFO (f
)->font_table
[already_loaded
].font
;
4743 /* Otherwise, load the font and add it to the table. */
4752 /* Try to find a character-cell font in the list. */
4754 /* A laudable goal, but this isn't how to do it. */
4755 for (i
= 0; i
< n_matching_fonts
; i
++)
4756 if (! font_info
[i
].per_char
)
4762 /* See comment above. */
4763 if (n_matching_fonts
!= 0)
4764 fontname
= font_names
[i
];
4766 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
4769 /* Free the information from XListFonts. */
4770 if (n_matching_fonts
)
4771 XFreeFontNames (font_names
);
4775 /* Do we need to create the table? */
4776 if (FRAME_X_DISPLAY_INFO (f
)->font_table_size
== 0)
4778 FRAME_X_DISPLAY_INFO (f
)->font_table_size
= 16;
4779 FRAME_X_DISPLAY_INFO (f
)->font_table
4780 = (struct font_info
*) xmalloc (FRAME_X_DISPLAY_INFO (f
)->font_table_size
4781 * sizeof (struct font_info
));
4783 /* Do we need to grow the table? */
4784 else if (FRAME_X_DISPLAY_INFO (f
)->n_fonts
4785 >= FRAME_X_DISPLAY_INFO (f
)->font_table_size
)
4787 FRAME_X_DISPLAY_INFO (f
)->font_table_size
*= 2;
4788 FRAME_X_DISPLAY_INFO (f
)->font_table
4789 = (struct font_info
*) xrealloc (FRAME_X_DISPLAY_INFO (f
)->font_table
,
4790 (FRAME_X_DISPLAY_INFO (f
)->font_table_size
4791 * sizeof (struct font_info
)));
4794 /* Try to get the full name of FONT. Put it in full_name. */
4796 FONT_atom
= XInternAtom (FRAME_X_DISPLAY (f
), "FONT", False
);
4797 for (i
= 0; i
< font
->n_properties
; i
++)
4799 if (FONT_atom
== font
->properties
[i
].name
)
4801 char *name
= XGetAtomName (FRAME_X_DISPLAY (f
),
4802 (Atom
) (font
->properties
[i
].card32
));
4806 /* Count the number of dashes in the "full name".
4807 If it is too few, this isn't really the font's full name,
4809 In X11R4, the fonts did not come with their canonical names
4825 n_fonts
= FRAME_X_DISPLAY_INFO (f
)->n_fonts
;
4826 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
= (char *) xmalloc (strlen (fontname
) + 1);
4827 bcopy (fontname
, FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
, strlen (fontname
) + 1);
4829 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].full_name
= full_name
;
4831 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].full_name
= FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
;
4832 f
->output_data
.x
->font
= FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].font
= font
;
4833 FRAME_X_DISPLAY_INFO (f
)->n_fonts
++;
4836 fontname
= full_name
;
4839 /* Compute the scroll bar width in character columns. */
4840 if (f
->scroll_bar_pixel_width
> 0)
4842 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
4843 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
4846 f
->scroll_bar_cols
= 2;
4848 /* Now make the frame display the given font. */
4849 if (FRAME_X_WINDOW (f
) != 0)
4851 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
4852 f
->output_data
.x
->font
->fid
);
4853 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
4854 f
->output_data
.x
->font
->fid
);
4855 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
4856 f
->output_data
.x
->font
->fid
);
4858 frame_update_line_height (f
);
4859 x_set_window_size (f
, 0, f
->width
, f
->height
);
4862 /* If we are setting a new frame's font for the first time,
4863 there are no faces yet, so this font's height is the line height. */
4864 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
4867 Lisp_Object lispy_name
;
4869 lispy_name
= build_string (fontname
);
4871 /* Free the information from XListFonts. The data
4872 we actually retain comes from XLoadQueryFont. */
4873 XFreeFontNames (font_names
);
4879 /* Calculate the absolute position in frame F
4880 from its current recorded position values and gravity. */
4882 x_calc_absolute_position (f
)
4886 int win_x
= 0, win_y
= 0;
4887 int flags
= f
->output_data
.x
->size_hint_flags
;
4890 #ifdef USE_X_TOOLKIT
4891 this_window
= XtWindow (f
->output_data
.x
->widget
);
4893 this_window
= FRAME_X_WINDOW (f
);
4896 /* Find the position of the outside upper-left corner of
4897 the inner window, with respect to the outer window. */
4898 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
4901 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
4903 /* From-window, to-window. */
4905 f
->output_data
.x
->parent_desc
,
4907 /* From-position, to-position. */
4908 0, 0, &win_x
, &win_y
,
4915 /* Treat negative positions as relative to the leftmost bottommost
4916 position that fits on the screen. */
4917 if (flags
& XNegative
)
4918 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
4919 - 2 * f
->output_data
.x
->border_width
- win_x
4921 + f
->output_data
.x
->left_pos
);
4923 if (flags
& YNegative
)
4924 /* We used to subtract f->output_data.x->menubar_height here
4925 in the toolkit case, but PIXEL_HEIGHT already includes that. */
4926 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
4927 - 2 * f
->output_data
.x
->border_width
- win_y
4929 + f
->output_data
.x
->top_pos
);
4931 /* The left_pos and top_pos
4932 are now relative to the top and left screen edges,
4933 so the flags should correspond. */
4934 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
4937 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
4938 to really change the position, and 0 when calling from
4939 x_make_frame_visible (in that case, XOFF and YOFF are the current
4940 position values). It is -1 when calling from x_set_frame_parameters,
4941 which means, do adjust for borders but don't change the gravity. */
4943 x_set_offset (f
, xoff
, yoff
, change_gravity
)
4945 register int xoff
, yoff
;
4948 int modified_top
, modified_left
;
4950 if (change_gravity
> 0)
4952 f
->output_data
.x
->top_pos
= yoff
;
4953 f
->output_data
.x
->left_pos
= xoff
;
4954 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
4956 f
->output_data
.x
->size_hint_flags
|= XNegative
;
4958 f
->output_data
.x
->size_hint_flags
|= YNegative
;
4959 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
4961 x_calc_absolute_position (f
);
4964 x_wm_set_size_hint (f
, (long) 0, 0);
4966 /* It is a mystery why we need to add the border_width here
4967 when the frame is already visible, but experiment says we do. */
4968 modified_left
= f
->output_data
.x
->left_pos
;
4969 modified_top
= f
->output_data
.x
->top_pos
;
4970 if (change_gravity
!= 0)
4972 modified_left
+= f
->output_data
.x
->border_width
;
4973 modified_top
+= f
->output_data
.x
->border_width
;
4976 #ifdef USE_X_TOOLKIT
4977 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
4978 modified_left
, modified_top
);
4979 #else /* not USE_X_TOOLKIT */
4980 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4981 modified_left
, modified_top
);
4982 #endif /* not USE_X_TOOLKIT */
4986 /* Call this to change the size of frame F's x-window.
4987 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
4988 for this size change and subsequent size changes.
4989 Otherwise we leave the window gravity unchanged. */
4991 x_set_window_size (f
, change_gravity
, cols
, rows
)
4996 int pixelwidth
, pixelheight
;
4999 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5003 #ifdef USE_X_TOOLKIT
5005 /* The x and y position of the widget is clobbered by the
5006 call to XtSetValues within EmacsFrameSetCharSize.
5007 This is a real kludge, but I don't understand Xt so I can't
5008 figure out a correct fix. Can anyone else tell me? -- rms. */
5009 int xpos
= f
->output_data
.x
->widget
->core
.x
;
5010 int ypos
= f
->output_data
.x
->widget
->core
.y
;
5011 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
5012 f
->output_data
.x
->widget
->core
.x
= xpos
;
5013 f
->output_data
.x
->widget
->core
.y
= ypos
;
5016 #else /* not USE_X_TOOLKIT */
5018 check_frame_size (f
, &rows
, &cols
);
5019 f
->output_data
.x
->vertical_scroll_bar_extra
5020 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5022 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
5023 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
5024 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
5025 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
5026 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
5028 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
5029 x_wm_set_size_hint (f
, (long) 0, 0);
5031 XSync (FRAME_X_DISPLAY (f
), False
);
5032 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5033 pixelwidth
, pixelheight
);
5035 /* Now, strictly speaking, we can't be sure that this is accurate,
5036 but the window manager will get around to dealing with the size
5037 change request eventually, and we'll hear how it went when the
5038 ConfigureNotify event gets here.
5040 We could just not bother storing any of this information here,
5041 and let the ConfigureNotify event set everything up, but that
5042 might be kind of confusing to the lisp code, since size changes
5043 wouldn't be reported in the frame parameters until some random
5044 point in the future when the ConfigureNotify event arrives. */
5045 change_frame_size (f
, rows
, cols
, 0, 0);
5046 PIXEL_WIDTH (f
) = pixelwidth
;
5047 PIXEL_HEIGHT (f
) = pixelheight
;
5049 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5050 receive in the ConfigureNotify event; if we get what we asked
5051 for, then the event won't cause the screen to become garbaged, so
5052 we have to make sure to do it here. */
5053 SET_FRAME_GARBAGED (f
);
5055 XFlush (FRAME_X_DISPLAY (f
));
5057 #endif /* not USE_X_TOOLKIT */
5059 /* If cursor was outside the new size, mark it as off. */
5060 if (f
->phys_cursor_y
>= rows
5061 || f
->phys_cursor_x
>= cols
)
5063 f
->phys_cursor_x
= -1;
5064 f
->phys_cursor_y
= -1;
5067 /* Clear out any recollection of where the mouse highlighting was,
5068 since it might be in a place that's outside the new frame size.
5069 Actually checking whether it is outside is a pain in the neck,
5070 so don't try--just let the highlighting be done afresh with new size. */
5071 window
= dpyinfo
->mouse_face_window
;
5072 if (! NILP (window
) && XFRAME (window
) == f
)
5074 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
5075 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
5076 dpyinfo
->mouse_face_window
= Qnil
;
5082 /* Mouse warping. */
5085 x_set_mouse_position (f
, x
, y
)
5091 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
5092 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
5094 if (pix_x
< 0) pix_x
= 0;
5095 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
5097 if (pix_y
< 0) pix_y
= 0;
5098 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
5102 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
5103 0, 0, 0, 0, pix_x
, pix_y
);
5107 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
5110 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
5116 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
5117 0, 0, 0, 0, pix_x
, pix_y
);
5121 /* focus shifting, raising and lowering. */
5123 x_focus_on_frame (f
)
5126 #if 0 /* This proves to be unpleasant. */
5130 /* I don't think that the ICCCM allows programs to do things like this
5131 without the interaction of the window manager. Whatever you end up
5132 doing with this code, do it to x_unfocus_frame too. */
5133 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5134 RevertToPointerRoot
, CurrentTime
);
5142 /* Look at the remarks in x_focus_on_frame. */
5143 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
5144 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
5145 RevertToPointerRoot
, CurrentTime
);
5149 /* Raise frame F. */
5154 if (f
->async_visible
)
5157 #ifdef USE_X_TOOLKIT
5158 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
5159 #else /* not USE_X_TOOLKIT */
5160 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5161 #endif /* not USE_X_TOOLKIT */
5162 XFlush (FRAME_X_DISPLAY (f
));
5167 /* Lower frame F. */
5172 if (f
->async_visible
)
5175 #ifdef USE_X_TOOLKIT
5176 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
5177 #else /* not USE_X_TOOLKIT */
5178 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5179 #endif /* not USE_X_TOOLKIT */
5180 XFlush (FRAME_X_DISPLAY (f
));
5186 XTframe_raise_lower (f
, raise_flag
)
5196 /* Change of visibility. */
5198 /* This tries to wait until the frame is really visible.
5199 However, if the window manager asks the user where to position
5200 the frame, this will return before the user finishes doing that.
5201 The frame will not actually be visible at that time,
5202 but it will become visible later when the window manager
5203 finishes with it. */
5205 x_make_frame_visible (f
)
5213 type
= x_icon_type (f
);
5215 x_bitmap_icon (f
, type
);
5217 if (! FRAME_VISIBLE_P (f
))
5219 /* We test FRAME_GARBAGED_P here to make sure we don't
5220 call x_set_offset a second time
5221 if we get to x_make_frame_visible a second time
5222 before the window gets really visible. */
5223 if (! FRAME_ICONIFIED_P (f
)
5224 && ! f
->output_data
.x
->asked_for_visible
)
5225 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
5227 f
->output_data
.x
->asked_for_visible
= 1;
5229 if (! EQ (Vx_no_window_manager
, Qt
))
5230 x_wm_set_window_state (f
, NormalState
);
5231 #ifdef USE_X_TOOLKIT
5232 /* This was XtPopup, but that did nothing for an iconified frame. */
5233 XtMapWidget (f
->output_data
.x
->widget
);
5234 #else /* not USE_X_TOOLKIT */
5235 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5236 #endif /* not USE_X_TOOLKIT */
5237 #if 0 /* This seems to bring back scroll bars in the wrong places
5238 if the window configuration has changed. They seem
5239 to come back ok without this. */
5240 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5241 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5245 XFlush (FRAME_X_DISPLAY (f
));
5247 /* Synchronize to ensure Emacs knows the frame is visible
5248 before we do anything else. We do this loop with input not blocked
5249 so that incoming events are handled. */
5252 int count
= input_signal_count
;
5254 /* This must come after we set COUNT. */
5257 XSETFRAME (frame
, f
);
5262 /* Once we have handled input events,
5263 we should have received the MapNotify if one is coming.
5264 So if we have not got it yet, stop looping.
5265 Some window managers make their own decisions
5266 about visibility. */
5267 if (input_signal_count
!= count
)
5269 /* Machines that do polling rather than SIGIO have been observed
5270 to go into a busy-wait here. So we'll fake an alarm signal
5271 to let the handler know that there's something to be read.
5272 We used to raise a real alarm, but it seems that the handler
5273 isn't always enabled here. This is probably a bug. */
5274 if (input_polling_used ())
5276 /* It could be confusing if a real alarm arrives while processing
5277 the fake one. Turn it off and let the handler reset it. */
5279 input_poll_signal ();
5281 /* Once we have handled input events,
5282 we should have received the MapNotify if one is coming.
5283 So if we have not got it yet, stop looping.
5284 Some window managers make their own decisions
5285 about visibility. */
5286 if (input_signal_count
!= count
)
5289 FRAME_SAMPLE_VISIBILITY (f
);
5293 /* Change from mapped state to withdrawn state. */
5295 /* Make the frame visible (mapped and not iconified). */
5297 x_make_frame_invisible (f
)
5303 #ifdef USE_X_TOOLKIT
5304 /* Use the frame's outermost window, not the one we normally draw on. */
5305 window
= XtWindow (f
->output_data
.x
->widget
);
5306 #else /* not USE_X_TOOLKIT */
5307 window
= FRAME_X_WINDOW (f
);
5308 #endif /* not USE_X_TOOLKIT */
5310 /* Don't keep the highlight on an invisible frame. */
5311 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5312 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5314 #if 0/* This might add unreliability; I don't trust it -- rms. */
5315 if (! f
->async_visible
&& ! f
->async_iconified
)
5321 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
5322 that the current position of the window is user-specified, rather than
5323 program-specified, so that when the window is mapped again, it will be
5324 placed at the same location, without forcing the user to position it
5325 by hand again (they have already done that once for this window.) */
5326 x_wm_set_size_hint (f
, (long) 0, 1);
5330 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
5331 DefaultScreen (FRAME_X_DISPLAY (f
))))
5333 UNBLOCK_INPUT_RESIGNAL
;
5334 error ("Can't notify window manager of window withdrawal");
5336 #else /* ! defined (HAVE_X11R4) */
5338 /* Tell the window manager what we're going to do. */
5339 if (! EQ (Vx_no_window_manager
, Qt
))
5343 unmap
.xunmap
.type
= UnmapNotify
;
5344 unmap
.xunmap
.window
= window
;
5345 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
5346 unmap
.xunmap
.from_configure
= False
;
5347 if (! XSendEvent (FRAME_X_DISPLAY (f
),
5348 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
5350 SubstructureRedirectMask
|SubstructureNotifyMask
,
5353 UNBLOCK_INPUT_RESIGNAL
;
5354 error ("Can't notify window manager of withdrawal");
5358 /* Unmap the window ourselves. Cheeky! */
5359 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
5360 #endif /* ! defined (HAVE_X11R4) */
5362 /* We can't distinguish this from iconification
5363 just by the event that we get from the server.
5364 So we can't win using the usual strategy of letting
5365 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5366 and synchronize with the server to make sure we agree. */
5368 FRAME_ICONIFIED_P (f
) = 0;
5369 f
->async_visible
= 0;
5370 f
->async_iconified
= 0;
5377 /* Change window state from mapped to iconified. */
5386 /* Don't keep the highlight on an invisible frame. */
5387 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5388 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5390 if (f
->async_iconified
)
5395 FRAME_SAMPLE_VISIBILITY (f
);
5397 type
= x_icon_type (f
);
5399 x_bitmap_icon (f
, type
);
5401 #ifdef USE_X_TOOLKIT
5403 if (! FRAME_VISIBLE_P (f
))
5405 if (! EQ (Vx_no_window_manager
, Qt
))
5406 x_wm_set_window_state (f
, IconicState
);
5407 /* This was XtPopup, but that did nothing for an iconified frame. */
5408 XtMapWidget (f
->output_data
.x
->widget
);
5409 /* The server won't give us any event to indicate
5410 that an invisible frame was changed to an icon,
5411 so we have to record it here. */
5413 f
->async_iconified
= 1;
5418 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
5419 XtWindow (f
->output_data
.x
->widget
),
5420 DefaultScreen (FRAME_X_DISPLAY (f
)));
5424 error ("Can't notify window manager of iconification");
5426 f
->async_iconified
= 1;
5429 XFlush (FRAME_X_DISPLAY (f
));
5431 #else /* not USE_X_TOOLKIT */
5433 /* Make sure the X server knows where the window should be positioned,
5434 in case the user deiconifies with the window manager. */
5435 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
5436 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
5438 /* Since we don't know which revision of X we're running, we'll use both
5439 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
5441 /* X11R4: send a ClientMessage to the window manager using the
5442 WM_CHANGE_STATE type. */
5446 message
.xclient
.window
= FRAME_X_WINDOW (f
);
5447 message
.xclient
.type
= ClientMessage
;
5448 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
5449 message
.xclient
.format
= 32;
5450 message
.xclient
.data
.l
[0] = IconicState
;
5452 if (! XSendEvent (FRAME_X_DISPLAY (f
),
5453 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
5455 SubstructureRedirectMask
| SubstructureNotifyMask
,
5458 UNBLOCK_INPUT_RESIGNAL
;
5459 error ("Can't notify window manager of iconification");
5463 /* X11R3: set the initial_state field of the window manager hints to
5465 x_wm_set_window_state (f
, IconicState
);
5467 if (!FRAME_VISIBLE_P (f
))
5469 /* If the frame was withdrawn, before, we must map it. */
5470 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5473 f
->async_iconified
= 1;
5475 XFlush (FRAME_X_DISPLAY (f
));
5477 #endif /* not USE_X_TOOLKIT */
5480 /* Destroy the X window of frame F. */
5482 x_destroy_window (f
)
5485 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5489 /* If a display connection is dead, don't try sending more
5490 commands to the X server. */
5491 if (dpyinfo
->display
!= 0)
5493 if (f
->output_data
.x
->icon_desc
!= 0)
5494 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
5498 XDestroyIC (FRAME_XIC (f
));
5499 #if ! defined (SOLARIS2) || defined (HAVE_X11R6)
5500 /* This line causes crashes on Solaris with Openwin,
5501 due to an apparent bug in XCloseIM.
5502 X11R6 seems not to have the bug. */
5503 XCloseIM (FRAME_XIM (f
));
5507 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->window_desc
);
5508 #ifdef USE_X_TOOLKIT
5509 XtDestroyWidget (f
->output_data
.x
->widget
);
5510 free_frame_menubar (f
);
5511 #endif /* USE_X_TOOLKIT */
5513 free_frame_faces (f
);
5514 XFlush (FRAME_X_DISPLAY (f
));
5517 xfree (f
->output_data
.x
);
5518 f
->output_data
.x
= 0;
5519 if (f
== dpyinfo
->x_focus_frame
)
5520 dpyinfo
->x_focus_frame
= 0;
5521 if (f
== dpyinfo
->x_focus_event_frame
)
5522 dpyinfo
->x_focus_event_frame
= 0;
5523 if (f
== dpyinfo
->x_highlight_frame
)
5524 dpyinfo
->x_highlight_frame
= 0;
5526 dpyinfo
->reference_count
--;
5528 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5530 dpyinfo
->mouse_face_beg_row
5531 = dpyinfo
->mouse_face_beg_col
= -1;
5532 dpyinfo
->mouse_face_end_row
5533 = dpyinfo
->mouse_face_end_col
= -1;
5534 dpyinfo
->mouse_face_window
= Qnil
;
5540 /* Setting window manager hints. */
5542 /* Set the normal size hints for the window manager, for frame F.
5543 FLAGS is the flags word to use--or 0 meaning preserve the flags
5544 that the window now has.
5545 If USER_POSITION is nonzero, we set the USPosition
5546 flag (this is useful when FLAGS is 0). */
5548 x_wm_set_size_hint (f
, flags
, user_position
)
5553 XSizeHints size_hints
;
5555 #ifdef USE_X_TOOLKIT
5558 Dimension widget_width
, widget_height
;
5559 Window window
= XtWindow (f
->output_data
.x
->widget
);
5560 #else /* not USE_X_TOOLKIT */
5561 Window window
= FRAME_X_WINDOW (f
);
5562 #endif /* not USE_X_TOOLKIT */
5564 /* Setting PMaxSize caused various problems. */
5565 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
5567 flexlines
= f
->height
;
5569 size_hints
.x
= f
->output_data
.x
->left_pos
;
5570 size_hints
.y
= f
->output_data
.x
->top_pos
;
5572 #ifdef USE_X_TOOLKIT
5573 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
5574 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
5575 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
5576 size_hints
.height
= widget_height
;
5577 size_hints
.width
= widget_width
;
5578 #else /* not USE_X_TOOLKIT */
5579 size_hints
.height
= PIXEL_HEIGHT (f
);
5580 size_hints
.width
= PIXEL_WIDTH (f
);
5581 #endif /* not USE_X_TOOLKIT */
5583 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
5584 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
5585 size_hints
.max_width
5586 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
5587 size_hints
.max_height
5588 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
5590 /* Calculate the base and minimum sizes.
5592 (When we use the X toolkit, we don't do it here.
5593 Instead we copy the values that the widgets are using, below.) */
5594 #ifndef USE_X_TOOLKIT
5596 int base_width
, base_height
;
5597 int min_rows
= 0, min_cols
= 0;
5599 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
5600 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
5602 check_frame_size (f
, &min_rows
, &min_cols
);
5604 /* The window manager uses the base width hints to calculate the
5605 current number of rows and columns in the frame while
5606 resizing; min_width and min_height aren't useful for this
5607 purpose, since they might not give the dimensions for a
5608 zero-row, zero-column frame.
5610 We use the base_width and base_height members if we have
5611 them; otherwise, we set the min_width and min_height members
5612 to the size for a zero x zero frame. */
5615 size_hints
.flags
|= PBaseSize
;
5616 size_hints
.base_width
= base_width
;
5617 size_hints
.base_height
= base_height
;
5618 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
5619 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
5621 size_hints
.min_width
= base_width
;
5622 size_hints
.min_height
= base_height
;
5626 /* If we don't need the old flags, we don't need the old hint at all. */
5629 size_hints
.flags
|= flags
;
5632 #endif /* not USE_X_TOOLKIT */
5635 XSizeHints hints
; /* Sometimes I hate X Windows... */
5636 long supplied_return
;
5640 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
5643 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
5646 #ifdef USE_X_TOOLKIT
5647 size_hints
.base_height
= hints
.base_height
;
5648 size_hints
.base_width
= hints
.base_width
;
5649 size_hints
.min_height
= hints
.min_height
;
5650 size_hints
.min_width
= hints
.min_width
;
5654 size_hints
.flags
|= flags
;
5659 if (hints
.flags
& PSize
)
5660 size_hints
.flags
|= PSize
;
5661 if (hints
.flags
& PPosition
)
5662 size_hints
.flags
|= PPosition
;
5663 if (hints
.flags
& USPosition
)
5664 size_hints
.flags
|= USPosition
;
5665 if (hints
.flags
& USSize
)
5666 size_hints
.flags
|= USSize
;
5673 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
5674 size_hints
.flags
|= PWinGravity
;
5678 size_hints
.flags
&= ~ PPosition
;
5679 size_hints
.flags
|= USPosition
;
5681 #endif /* PWinGravity */
5684 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
5686 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
5690 /* Used for IconicState or NormalState */
5691 x_wm_set_window_state (f
, state
)
5695 #ifdef USE_X_TOOLKIT
5698 XtSetArg (al
[0], XtNinitialState
, state
);
5699 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
5700 #else /* not USE_X_TOOLKIT */
5701 Window window
= FRAME_X_WINDOW (f
);
5703 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
5704 f
->output_data
.x
->wm_hints
.initial_state
= state
;
5706 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5707 #endif /* not USE_X_TOOLKIT */
5710 x_wm_set_icon_pixmap (f
, pixmap_id
)
5716 #ifdef USE_X_TOOLKIT
5717 Window window
= XtWindow (f
->output_data
.x
->widget
);
5719 Window window
= FRAME_X_WINDOW (f
);
5724 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
5725 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
5729 /* It seems there is no way to turn off use of an icon pixmap.
5730 The following line does it, only if no icon has yet been created,
5731 for some window managers. But with mwm it crashes.
5732 Some people say it should clear the IconPixmapHint bit in this case,
5733 but that doesn't work, and the X consortium said it isn't the
5734 right thing at all. Since there is no way to win,
5735 best to explicitly give up. */
5737 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
5743 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
5747 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
5748 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
5751 #else /* not USE_X_TOOLKIT */
5753 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
5754 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5756 #endif /* not USE_X_TOOLKIT */
5759 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5763 #ifdef USE_X_TOOLKIT
5764 Window window
= XtWindow (f
->output_data
.x
->widget
);
5766 Window window
= FRAME_X_WINDOW (f
);
5769 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
5770 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
5771 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
5773 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5777 /* Initialization. */
5779 #ifdef USE_X_TOOLKIT
5780 static XrmOptionDescRec emacs_options
[] = {
5781 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
5782 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
5784 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
5785 XrmoptionSepArg
, NULL
},
5786 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
5788 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5789 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5790 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5791 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5792 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5793 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
5794 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
5796 #endif /* USE_X_TOOLKIT */
5798 static int x_initialized
;
5801 /* Test whether two display-name strings agree up to the dot that separates
5802 the screen number from the server number. */
5804 same_x_server (name1
, name2
)
5805 char *name1
, *name2
;
5808 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
5812 if (seen_colon
&& *name1
== '.')
5816 && (*name1
== '.' || *name1
== '\0')
5817 && (*name2
== '.' || *name2
== '\0'));
5821 struct x_display_info
*
5822 x_term_init (display_name
, xrm_option
, resource_name
)
5823 Lisp_Object display_name
;
5825 char *resource_name
;
5831 struct x_display_info
*dpyinfo
;
5843 setlocale (LC_ALL
, "");
5844 /* In case we just overrode what init_lread did, redo it. */
5845 setlocale (LC_NUMERIC
, "C");
5846 setlocale (LC_TIME
, "C");
5849 #ifdef USE_X_TOOLKIT
5850 /* weiner@footloose.sps.mot.com reports that this causes
5852 X protocol error: BadAtom (invalid Atom parameter)
5853 on protocol request 18skiloaf.
5854 So let's not use it until R6. */
5856 XtSetLanguageProc (NULL
, NULL
, NULL
);
5867 argv
[argc
++] = "-xrm";
5868 argv
[argc
++] = xrm_option
;
5870 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
5871 resource_name
, EMACS_CLASS
,
5872 emacs_options
, XtNumber (emacs_options
),
5876 /* I think this is to compensate for XtSetLanguageProc. */
5877 setlocale (LC_NUMERIC
, "C");
5878 setlocale (LC_TIME
, "C");
5882 #else /* not USE_X_TOOLKIT */
5884 XSetLocaleModifiers ("");
5886 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
5887 #endif /* not USE_X_TOOLKIT */
5889 /* Detect failure. */
5896 /* We have definitely succeeded. Record the new connection. */
5898 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
5902 struct x_display_info
*share
;
5905 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
5906 share
= share
->next
, tail
= XCONS (tail
)->cdr
)
5907 if (same_x_server (XSTRING (XCONS (XCONS (tail
)->car
)->car
)->data
,
5908 XSTRING (display_name
)->data
))
5911 dpyinfo
->kboard
= share
->kboard
;
5914 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
5915 init_kboard (dpyinfo
->kboard
);
5916 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
5918 char *vendor
= ServerVendor (dpy
);
5919 dpyinfo
->kboard
->Vsystem_key_alist
5920 = call1 (Qvendor_specific_keysyms
,
5921 build_string (vendor
? vendor
: ""));
5924 dpyinfo
->kboard
->next_kboard
= all_kboards
;
5925 all_kboards
= dpyinfo
->kboard
;
5926 /* Don't let the initial kboard remain current longer than necessary.
5927 That would cause problems if a file loaded on startup tries to
5928 prompt in the minibuffer. */
5929 if (current_kboard
== initial_kboard
)
5930 current_kboard
= dpyinfo
->kboard
;
5932 dpyinfo
->kboard
->reference_count
++;
5936 /* Put this display on the chain. */
5937 dpyinfo
->next
= x_display_list
;
5938 x_display_list
= dpyinfo
;
5940 /* Put it on x_display_name_list as well, to keep them parallel. */
5941 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
5942 x_display_name_list
);
5943 dpyinfo
->name_list_element
= XCONS (x_display_name_list
)->car
;
5945 dpyinfo
->display
= dpy
;
5948 XSetAfterFunction (x_current_display
, x_trace_wire
);
5952 = (char *) xmalloc (XSTRING (Vinvocation_name
)->size
5953 + XSTRING (Vsystem_name
)->size
5955 sprintf (dpyinfo
->x_id_name
, "%s@%s",
5956 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
5958 /* Figure out which modifier bits mean what. */
5959 x_find_modifier_meanings (dpyinfo
);
5961 /* Get the scroll bar cursor. */
5962 dpyinfo
->vertical_scroll_bar_cursor
5963 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
5965 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
5966 resource_name
, EMACS_CLASS
);
5967 #ifdef HAVE_XRMSETDATABASE
5968 XrmSetDatabase (dpyinfo
->display
, xrdb
);
5970 dpyinfo
->display
->db
= xrdb
;
5972 /* Put the rdb where we can find it in a way that works on
5974 dpyinfo
->xrdb
= xrdb
;
5976 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
5977 DefaultScreen (dpyinfo
->display
));
5978 dpyinfo
->visual
= select_visual (dpyinfo
->display
, dpyinfo
->screen
,
5979 &dpyinfo
->n_planes
);
5980 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
5981 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
5982 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
5983 dpyinfo
->grabbed
= 0;
5984 dpyinfo
->reference_count
= 0;
5985 dpyinfo
->icon_bitmap_id
= -1;
5986 dpyinfo
->n_fonts
= 0;
5987 dpyinfo
->font_table_size
= 0;
5988 dpyinfo
->bitmaps
= 0;
5989 dpyinfo
->bitmaps_size
= 0;
5990 dpyinfo
->bitmaps_last
= 0;
5991 dpyinfo
->scratch_cursor_gc
= 0;
5992 dpyinfo
->mouse_face_mouse_frame
= 0;
5993 dpyinfo
->mouse_face_deferred_gc
= 0;
5994 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
5995 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
5996 dpyinfo
->mouse_face_face_id
= 0;
5997 dpyinfo
->mouse_face_window
= Qnil
;
5998 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
5999 dpyinfo
->mouse_face_defer
= 0;
6000 dpyinfo
->x_focus_frame
= 0;
6001 dpyinfo
->x_focus_event_frame
= 0;
6002 dpyinfo
->x_highlight_frame
= 0;
6004 dpyinfo
->Xatom_wm_protocols
6005 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
6006 dpyinfo
->Xatom_wm_take_focus
6007 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
6008 dpyinfo
->Xatom_wm_save_yourself
6009 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
6010 dpyinfo
->Xatom_wm_delete_window
6011 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
6012 dpyinfo
->Xatom_wm_change_state
6013 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
6014 dpyinfo
->Xatom_wm_configure_denied
6015 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
6016 dpyinfo
->Xatom_wm_window_moved
6017 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
6018 dpyinfo
->Xatom_editres
6019 = XInternAtom (dpyinfo
->display
, "Editres", False
);
6020 dpyinfo
->Xatom_CLIPBOARD
6021 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
6022 dpyinfo
->Xatom_TIMESTAMP
6023 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
6025 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
6026 dpyinfo
->Xatom_DELETE
6027 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
6028 dpyinfo
->Xatom_MULTIPLE
6029 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
6031 = XInternAtom (dpyinfo
->display
, "INCR", False
);
6032 dpyinfo
->Xatom_EMACS_TMP
6033 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
6034 dpyinfo
->Xatom_TARGETS
6035 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
6037 = XInternAtom (dpyinfo
->display
, "NULL", False
);
6038 dpyinfo
->Xatom_ATOM_PAIR
6039 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
6041 dpyinfo
->cut_buffers_initialized
= 0;
6043 connection
= ConnectionNumber (dpyinfo
->display
);
6044 dpyinfo
->connection
= connection
;
6047 /* This is only needed for distinguishing keyboard and process input. */
6048 if (connection
!= 0)
6049 add_keyboard_wait_descriptor (connection
);
6052 #ifndef F_SETOWN_BUG
6054 #ifdef F_SETOWN_SOCK_NEG
6055 /* stdin is a socket here */
6056 fcntl (connection
, F_SETOWN
, -getpid ());
6057 #else /* ! defined (F_SETOWN_SOCK_NEG) */
6058 fcntl (connection
, F_SETOWN
, getpid ());
6059 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
6060 #endif /* ! defined (F_SETOWN) */
6061 #endif /* F_SETOWN_BUG */
6064 if (interrupt_input
)
6065 init_sigio (connection
);
6066 #endif /* ! defined (SIGIO) */
6073 /* Get rid of display DPYINFO, assuming all frames are already gone,
6074 and without sending any more commands to the X server. */
6077 x_delete_display (dpyinfo
)
6078 struct x_display_info
*dpyinfo
;
6080 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
6082 /* Discard this display from x_display_name_list and x_display_list.
6083 We can't use Fdelq because that can quit. */
6084 if (! NILP (x_display_name_list
)
6085 && EQ (XCONS (x_display_name_list
)->car
, dpyinfo
->name_list_element
))
6086 x_display_name_list
= XCONS (x_display_name_list
)->cdr
;
6091 tail
= x_display_name_list
;
6092 while (CONSP (tail
) && CONSP (XCONS (tail
)->cdr
))
6094 if (EQ (XCONS (XCONS (tail
)->cdr
)->car
,
6095 dpyinfo
->name_list_element
))
6097 XCONS (tail
)->cdr
= XCONS (XCONS (tail
)->cdr
)->cdr
;
6100 tail
= XCONS (tail
)->cdr
;
6104 if (x_display_list
== dpyinfo
)
6105 x_display_list
= dpyinfo
->next
;
6108 struct x_display_info
*tail
;
6110 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
6111 if (tail
->next
== dpyinfo
)
6112 tail
->next
= tail
->next
->next
;
6115 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
6116 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
6117 XrmDestroyDatabase (dpyinfo
->xrdb
);
6121 if (--dpyinfo
->kboard
->reference_count
== 0)
6122 delete_kboard (dpyinfo
->kboard
);
6124 xfree (dpyinfo
->font_table
);
6125 xfree (dpyinfo
->x_id_name
);
6129 /* Set up use of X before we make the first connection. */
6133 clear_frame_hook
= XTclear_frame
;
6134 clear_end_of_line_hook
= XTclear_end_of_line
;
6135 ins_del_lines_hook
= XTins_del_lines
;
6136 change_line_highlight_hook
= XTchange_line_highlight
;
6137 insert_glyphs_hook
= XTinsert_glyphs
;
6138 write_glyphs_hook
= XTwrite_glyphs
;
6139 delete_glyphs_hook
= XTdelete_glyphs
;
6140 ring_bell_hook
= XTring_bell
;
6141 reset_terminal_modes_hook
= XTreset_terminal_modes
;
6142 set_terminal_modes_hook
= XTset_terminal_modes
;
6143 update_begin_hook
= XTupdate_begin
;
6144 update_end_hook
= XTupdate_end
;
6145 set_terminal_window_hook
= XTset_terminal_window
;
6146 read_socket_hook
= XTread_socket
;
6147 frame_up_to_date_hook
= XTframe_up_to_date
;
6148 cursor_to_hook
= XTcursor_to
;
6149 reassert_line_highlight_hook
= XTreassert_line_highlight
;
6150 mouse_position_hook
= XTmouse_position
;
6151 frame_rehighlight_hook
= XTframe_rehighlight
;
6152 frame_raise_lower_hook
= XTframe_raise_lower
;
6153 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
6154 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
6155 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
6156 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
6158 scroll_region_ok
= 1; /* we'll scroll partial frames */
6159 char_ins_del_ok
= 0; /* just as fast to write the line */
6160 line_ins_del_ok
= 1; /* we'll just blt 'em */
6161 fast_clear_end_of_line
= 1; /* X does this well */
6162 memory_below_frame
= 0; /* we don't remember what scrolls
6168 /* Try to use interrupt input; if we can't, then start polling. */
6169 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
6171 #ifdef USE_X_TOOLKIT
6172 XtToolkitInitialize ();
6173 Xt_app_con
= XtCreateApplicationContext ();
6174 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
6177 /* Note that there is no real way portable across R3/R4 to get the
6178 original error handler. */
6179 XSetErrorHandler (x_error_quitter
);
6180 XSetIOErrorHandler (x_io_error_quitter
);
6182 /* Disable Window Change signals; they are handled by X events. */
6184 signal (SIGWINCH
, SIG_DFL
);
6185 #endif /* ! defined (SIGWINCH) */
6187 signal (SIGPIPE
, x_connection_signal
);
6193 staticpro (&x_display_name_list
);
6194 x_display_name_list
= Qnil
;
6196 staticpro (&last_mouse_scroll_bar
);
6197 last_mouse_scroll_bar
= Qnil
;
6199 staticpro (&Qvendor_specific_keysyms
);
6200 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
6203 #endif /* not HAVE_X_WINDOWS */