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 extern void free_frame_menubar ();
89 extern FRAME_PTR
x_menubar_window_to_frame ();
90 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
92 extern void _XEditResCheckMessages ();
93 #endif /* not NO_EDITRES */
94 #endif /* USE_X_TOOLKIT */
97 #define x_any_window_to_frame x_window_to_frame
98 #define x_top_window_to_frame x_window_to_frame
103 #ifndef XtNinitialState
104 #define XtNinitialState "initialState"
108 #ifdef HAVE_SETLOCALE
109 /* So we can do setlocale. */
114 #define X_CONNECTION_LOCK_FLAG XlibDisplayWriting
118 #define min(a,b) ((a)<(b) ? (a) : (b))
121 #define max(a,b) ((a)>(b) ? (a) : (b))
124 /* This is a chain of structures for all the X displays currently in use. */
125 struct x_display_info
*x_display_list
;
127 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
128 one for each element of x_display_list and in the same order.
129 NAME is the name of the frame.
130 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
131 Lisp_Object x_display_name_list
;
133 /* Frame being updated by update_frame. This is declared in term.c.
134 This is set by update_begin and looked at by all the
135 XT functions. It is zero while not inside an update.
136 In that case, the XT functions assume that `selected_frame'
137 is the frame to apply to. */
138 extern struct frame
*updating_frame
;
140 /* This is a frame waiting to be autoraised, within XTread_socket. */
141 struct frame
*pending_autoraise_frame
;
144 /* The application context for Xt use. */
145 XtAppContext Xt_app_con
;
147 static String Xt_default_resources
[] =
153 /* During an update, maximum vpos for ins/del line operations to affect. */
155 static int flexlines
;
157 /* During an update, nonzero if chars output now should be highlighted. */
159 static int highlight
;
161 /* Nominal cursor position -- where to draw output.
162 During an update, these are different from the cursor-box position. */
169 Formerly, we used PointerMotionHintMask (in STANDARD_EVENT_MASK)
170 so that we would have to call XQueryPointer after each MotionNotify
171 event to ask for another such event. However, this made mouse tracking
172 slow, and there was a bug that made it eventually stop.
174 Simply asking for MotionNotify all the time seems to work better.
176 In order to avoid asking for motion events and then throwing most
177 of them away or busy-polling the server for mouse positions, we ask
178 the server for pointer motion hints. This means that we get only
179 one event per group of mouse movements. "Groups" are delimited by
180 other kinds of events (focus changes and button clicks, for
181 example), or by XQueryPointer calls; when one of these happens, we
182 get another MotionNotify event the next time the mouse moves. This
183 is at least as efficient as getting motion events when mouse
184 tracking is on, and I suspect only negligibly worse when tracking
187 /* Where the mouse was last time we reported a mouse event. */
188 static FRAME_PTR last_mouse_frame
;
189 static XRectangle last_mouse_glyph
;
191 /* The scroll bar in which the last X motion event occurred.
193 If the last X motion event occurred in a scroll bar, we set this
194 so XTmouse_position can know whether to report a scroll bar motion or
197 If the last X motion event didn't occur in a scroll bar, we set this
198 to Qnil, to tell XTmouse_position to return an ordinary motion event. */
199 static Lisp_Object last_mouse_scroll_bar
;
201 /* This is a hack. We would really prefer that XTmouse_position would
202 return the time associated with the position it returns, but there
203 doesn't seem to be any way to wrest the timestamp from the server
204 along with the position query. So, we just keep track of the time
205 of the last movement we received, and return that in hopes that
206 it's somewhat accurate. */
207 static Time last_mouse_movement_time
;
209 /* Incremented by XTread_socket whenever it really tries to read events. */
211 static int volatile input_signal_count
;
213 static int input_signal_count
;
216 /* Used locally within XTread_socket. */
217 static int x_noop_count
;
219 /* Initial values of argv and argc. */
220 extern char **initial_argv
;
221 extern int initial_argc
;
223 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
225 /* Tells if a window manager is present or not. */
227 extern Lisp_Object Vx_no_window_manager
;
229 extern Lisp_Object Qface
, Qmouse_face
;
233 /* A mask of extra modifier bits to put into every keyboard char. */
234 extern int extra_keyboard_modifiers
;
236 static Lisp_Object Qvendor_specific_keysyms
;
238 extern XrmDatabase
x_load_resources ();
240 extern Lisp_Object
x_icon_type ();
242 void x_delete_display ();
244 static void redraw_previous_char ();
245 static void redraw_following_char ();
246 static unsigned int x_x_to_emacs_modifiers ();
248 static int fast_find_position ();
249 static void note_mouse_highlight ();
250 static void clear_mouse_face ();
251 static void show_mouse_face ();
252 static void do_line_dance ();
254 static int XTcursor_to ();
255 static int XTclear_end_of_line ();
256 static int x_io_error_quitter ();
257 void x_catch_errors ();
258 void x_uncatch_errors ();
261 /* This is a function useful for recording debugging information
262 about the sequence of occurrences in this file. */
270 struct record event_record
[100];
272 int event_record_index
;
274 record_event (locus
, type
)
278 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
279 event_record_index
= 0;
281 event_record
[event_record_index
].locus
= locus
;
282 event_record
[event_record_index
].type
= type
;
283 event_record_index
++;
288 /* Return the struct x_display_info corresponding to DPY. */
290 struct x_display_info
*
291 x_display_info_for_display (dpy
)
294 struct x_display_info
*dpyinfo
;
296 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
297 if (dpyinfo
->display
== dpy
)
303 /* Starting and ending updates.
305 These hooks are called by update_frame at the beginning and end
306 of a frame update. We record in `updating_frame' the identity
307 of the frame being updated, so that the XT... functions do not
308 need to take a frame as argument. Most of the XT... functions
309 should never be called except during an update, the only exceptions
310 being XTcursor_to, XTwrite_glyphs and XTreassert_line_highlight. */
321 flexlines
= f
->height
;
326 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
328 /* Don't do highlighting for mouse motion during the update. */
329 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 1;
331 /* If the frame needs to be redrawn,
332 simply forget about any prior mouse highlighting. */
333 if (FRAME_GARBAGED_P (f
))
334 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= Qnil
;
336 if (!NILP (FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
))
338 int firstline
, lastline
, i
;
339 struct window
*w
= XWINDOW (FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
);
341 /* Find the first, and the last+1, lines affected by redisplay. */
342 for (firstline
= 0; firstline
< f
->height
; firstline
++)
343 if (FRAME_DESIRED_GLYPHS (f
)->enable
[firstline
])
346 lastline
= f
->height
;
347 for (i
= f
->height
- 1; i
>= 0; i
--)
349 if (FRAME_DESIRED_GLYPHS (f
)->enable
[i
])
355 /* Can we tell that this update does not affect the window
356 where the mouse highlight is? If so, no need to turn off.
357 Likewise, don't do anything if the frame is garbaged;
358 in that case, the FRAME_CURRENT_GLYPHS that we would use
359 are all wrong, and we will redisplay that line anyway. */
360 if (! (firstline
> (XFASTINT (w
->top
) + window_internal_height (w
))
361 || lastline
< XFASTINT (w
->top
)))
362 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
378 x_display_cursor (f
, 1);
380 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
381 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
383 /* This fails in the case of having updated only the echo area
384 if we have switched buffers. In that case, FRAME_CURRENT_GLYPHS
385 has no relation to the current contents, and its charstarts
386 have no relation to the contents of the window-buffer.
387 I don't know a clean way to check
388 for that case. window_end_valid isn't set up yet. */
389 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
390 note_mouse_highlight (f
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
391 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
394 XFlush (FRAME_X_DISPLAY (f
));
398 /* This is called after a redisplay on frame F. */
401 XTframe_up_to_date (f
)
405 if (FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
406 || f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
408 note_mouse_highlight (FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
,
409 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
410 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
411 FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 0;
416 /* External interface to control of standout mode.
417 Call this when about to modify line at position VPOS
418 and not change whether it is highlighted. */
420 XTreassert_line_highlight (new, vpos
)
426 /* Call this when about to modify line at position VPOS
427 and change whether it is highlighted. */
430 XTchange_line_highlight (new_highlight
, vpos
, first_unused_hpos
)
431 int new_highlight
, vpos
, first_unused_hpos
;
433 highlight
= new_highlight
;
434 XTcursor_to (vpos
, 0);
435 XTclear_end_of_line (updating_frame
->width
);
438 /* This is used when starting Emacs and when restarting after suspend.
439 When starting Emacs, no X window is mapped. And nothing must be done
440 to Emacs's own window if it is suspended (though that rarely happens). */
443 XTset_terminal_modes ()
447 /* This is called when exiting or suspending Emacs.
448 Exiting will make the X-windows go away, and suspending
449 requires no action. */
452 XTreset_terminal_modes ()
454 /* XTclear_frame (); */
457 /* Set the nominal cursor position of the frame.
458 This is where display update commands will take effect.
459 This does not affect the place where the cursor-box is displayed. */
462 XTcursor_to (row
, col
)
463 register int row
, col
;
471 if (updating_frame
== 0)
474 x_display_cursor (selected_frame
, 1);
475 XFlush (FRAME_X_DISPLAY (selected_frame
));
480 /* Display a sequence of N glyphs found at GP.
481 WINDOW is the x-window to output to. LEFT and TOP are starting coords.
482 HL is 1 if this text is highlighted, 2 if the cursor is on it,
483 3 if should appear in its mouse-face.
484 JUST_FOREGROUND if 1 means draw only the foreground;
485 don't alter the background.
487 FONT is the default font to use (for glyphs whose font-code is 0).
489 Since the display generation code is responsible for calling
490 compute_char_face and compute_glyph_face on everything it puts in
491 the display structure, we can assume that the face code on each
492 glyph is a valid index into FRAME_COMPUTED_FACES (f), and the one
493 to which we can actually apply intern_face.
494 Call this function with input blocked. */
497 /* This is the multi-face code. */
500 dumpglyphs (f
, left
, top
, gp
, n
, hl
, just_foreground
)
503 register GLYPH
*gp
; /* Points to first GLYPH. */
504 register int n
; /* Number of glyphs to display. */
508 /* Holds characters to be displayed. */
509 char *buf
= (char *) alloca (f
->width
* sizeof (*buf
));
510 register char *cp
; /* Steps through buf[]. */
511 register int tlen
= GLYPH_TABLE_LENGTH
;
512 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
513 Window window
= FRAME_X_WINDOW (f
);
514 int orig_left
= left
;
518 /* Get the face-code of the next GLYPH. */
522 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
523 cf
= FAST_GLYPH_FACE (g
);
525 /* Find the run of consecutive glyphs with the same face-code.
526 Extract their character codes into BUF. */
531 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
532 if (FAST_GLYPH_FACE (g
) != cf
)
535 *cp
++ = FAST_GLYPH_CHAR (g
);
540 /* LEN gets the length of the run. */
543 /* Now output this run of chars, with the font and pixel values
544 determined by the face code CF. */
546 struct face
*face
= FRAME_DEFAULT_FACE (f
);
547 XFontStruct
*font
= FACE_FONT (face
);
548 GC gc
= FACE_GC (face
);
551 /* HL = 3 means use a mouse face previously chosen. */
553 cf
= FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
;
555 /* First look at the face of the text itself. */
558 /* It's possible for the display table to specify
559 a face code that is out of range. Use 0 in that case. */
560 if (cf
< 0 || cf
>= FRAME_N_COMPUTED_FACES (f
)
561 || FRAME_COMPUTED_FACES (f
) [cf
] == 0)
565 face
= FRAME_MODE_LINE_FACE (f
);
567 face
= intern_face (f
, FRAME_COMPUTED_FACES (f
) [cf
]);
568 font
= FACE_FONT (face
);
570 if (FACE_STIPPLE (face
))
574 /* Then comes the distinction between modeline and normal text. */
579 face
= FRAME_MODE_LINE_FACE (f
);
580 font
= FACE_FONT (face
);
582 if (FACE_STIPPLE (face
))
586 #define FACE_DEFAULT (~0)
588 /* Now override that if the cursor's on this character. */
591 /* The cursor overrides stippling. */
595 || face
->font
== (XFontStruct
*) FACE_DEFAULT
596 || face
->font
== f
->output_data
.x
->font
)
597 && face
->background
== f
->output_data
.x
->background_pixel
598 && face
->foreground
== f
->output_data
.x
->foreground_pixel
)
600 gc
= f
->output_data
.x
->cursor_gc
;
602 /* Cursor on non-default face: must merge. */
608 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
609 xgcv
.foreground
= face
->background
;
610 /* If the glyph would be invisible,
611 try a different foreground. */
612 if (xgcv
.foreground
== xgcv
.background
)
613 xgcv
.foreground
= face
->foreground
;
614 if (xgcv
.foreground
== xgcv
.background
)
615 xgcv
.foreground
= f
->output_data
.x
->cursor_foreground_pixel
;
616 if (xgcv
.foreground
== xgcv
.background
)
617 xgcv
.foreground
= face
->foreground
;
618 /* Make sure the cursor is distinct from text in this face. */
619 if (xgcv
.background
== face
->background
620 && xgcv
.foreground
== face
->foreground
)
622 xgcv
.background
= face
->foreground
;
623 xgcv
.foreground
= face
->background
;
625 xgcv
.font
= face
->font
->fid
;
626 xgcv
.graphics_exposures
= 0;
627 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
628 if (FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
)
629 XChangeGC (FRAME_X_DISPLAY (f
),
630 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
,
633 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
634 = XCreateGC (FRAME_X_DISPLAY (f
), window
, mask
, &xgcv
);
635 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
637 /* If this code is restored, it must also reset to the default stipple
639 if (face
->stipple
&& face
->stipple
!= FACE_DEFAULT
)
640 XSetStipple (FRAME_X_DISPLAY (f
), gc
, face
->stipple
);
645 if (font
== (XFontStruct
*) FACE_DEFAULT
)
646 font
= f
->output_data
.x
->font
;
649 XDrawString (FRAME_X_DISPLAY (f
), window
, gc
,
650 left
, top
+ FONT_BASE (font
), buf
, len
);
655 /* Turn stipple on. */
656 XSetFillStyle (FRAME_X_DISPLAY (f
), gc
, FillOpaqueStippled
);
658 /* Draw stipple on background. */
659 XFillRectangle (FRAME_X_DISPLAY (f
), window
, gc
,
661 FONT_WIDTH (font
) * len
,
664 /* Turn stipple off. */
665 XSetFillStyle (FRAME_X_DISPLAY (f
), gc
, FillSolid
);
667 /* Draw the text, solidly, onto the stipple pattern. */
668 XDrawString (FRAME_X_DISPLAY (f
), window
, gc
,
669 left
, top
+ FONT_BASE (font
), buf
, len
);
672 XDrawImageString (FRAME_X_DISPLAY (f
), window
, gc
,
673 left
, top
+ FONT_BASE (font
), buf
, len
);
675 /* Clear the rest of the line's height. */
676 if (f
->output_data
.x
->line_height
!= FONT_HEIGHT (font
))
677 XClearArea (FRAME_X_DISPLAY (f
), window
, left
,
678 top
+ FONT_HEIGHT (font
),
679 FONT_WIDTH (font
) * len
,
680 /* This is how many pixels of height
682 f
->output_data
.x
->line_height
- FONT_HEIGHT (font
),
686 #if 0 /* Doesn't work, because it uses FRAME_CURRENT_GLYPHS,
687 which often is not up to date yet. */
688 if (!just_foreground
)
690 if (left
== orig_left
)
691 redraw_previous_char (f
, PIXEL_TO_CHAR_COL (f
, left
),
692 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
694 redraw_following_char (f
, PIXEL_TO_CHAR_COL (f
, left
+ len
* FONT_WIDTH (font
)),
695 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
699 /* We should probably check for XA_UNDERLINE_POSITION and
700 XA_UNDERLINE_THICKNESS properties on the font, but let's
701 just get the thing working, and come back to that. */
703 int underline_position
= 1;
705 if (font
->descent
<= underline_position
)
706 underline_position
= font
->descent
- 1;
709 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
713 + underline_position
),
714 len
* FONT_WIDTH (font
), 1);
717 left
+= len
* FONT_WIDTH (font
);
724 /* This is the old single-face code. */
727 dumpglyphs (f
, left
, top
, gp
, n
, hl
, font
)
730 register GLYPH
*gp
; /* Points to first GLYPH. */
731 register int n
; /* Number of glyphs to display. */
736 Window window
= FRAME_X_WINDOW (f
);
737 GC drawing_gc
= (hl
== 2 ? f
->output_data
.x
->cursor_gc
738 : (hl
? f
->output_data
.x
->reverse_gc
739 : f
->output_data
.x
->normal_gc
));
741 if (sizeof (GLYPH
) == sizeof (XChar2b
))
742 XDrawImageString16 (FRAME_X_DISPLAY (f
), window
, drawing_gc
,
743 left
, top
+ FONT_BASE (font
), (XChar2b
*) gp
, n
);
744 else if (sizeof (GLYPH
) == sizeof (unsigned char))
745 XDrawImageString (FRAME_X_DISPLAY (f
), window
, drawing_gc
,
746 left
, top
+ FONT_BASE (font
), (char *) gp
, n
);
748 /* What size of glyph ARE you using? And does X have a function to
754 /* Output some text at the nominal frame cursor position.
755 Advance the cursor over the text.
756 Output LEN glyphs at START.
758 `highlight', set up by XTreassert_line_highlight or XTchange_line_highlight,
759 controls the pixel values used for foreground and background. */
762 XTwrite_glyphs (start
, len
)
763 register GLYPH
*start
;
766 register int temp_length
;
777 /* If not within an update,
778 output at the frame's visible cursor. */
779 curs_x
= f
->cursor_x
;
780 curs_y
= f
->cursor_y
;
784 CHAR_TO_PIXEL_COL (f
, curs_x
),
785 CHAR_TO_PIXEL_ROW (f
, curs_y
),
786 start
, len
, highlight
, 0);
788 /* If we drew on top of the cursor, note that it is turned off. */
789 if (curs_y
== f
->phys_cursor_y
790 && curs_x
<= f
->phys_cursor_x
791 && curs_x
+ len
> f
->phys_cursor_x
)
792 f
->phys_cursor_x
= -1;
794 if (updating_frame
== 0)
797 x_display_cursor (f
, 1);
806 /* Clear to the end of the line.
807 Erase the current text line from the nominal cursor position (inclusive)
808 to column FIRST_UNUSED (exclusive). The idea is that everything
809 from FIRST_UNUSED onward is already erased. */
812 XTclear_end_of_line (first_unused
)
813 register int first_unused
;
815 struct frame
*f
= updating_frame
;
821 if (curs_y
< 0 || curs_y
>= f
->height
)
823 if (first_unused
<= 0)
826 if (first_unused
>= f
->width
)
827 first_unused
= f
->width
;
833 /* Notice if the cursor will be cleared by this operation. */
834 if (curs_y
== f
->phys_cursor_y
835 && curs_x
<= f
->phys_cursor_x
836 && f
->phys_cursor_x
< first_unused
)
837 f
->phys_cursor_x
= -1;
839 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
840 CHAR_TO_PIXEL_COL (f
, curs_x
),
841 CHAR_TO_PIXEL_ROW (f
, curs_y
),
842 FONT_WIDTH (f
->output_data
.x
->font
) * (first_unused
- curs_x
),
843 f
->output_data
.x
->line_height
, False
);
845 redraw_previous_char (f
, curs_x
, curs_y
, highlight
);
855 struct frame
*f
= updating_frame
;
860 f
->phys_cursor_x
= -1; /* Cursor not visible. */
861 curs_x
= 0; /* Nominal cursor position is top left. */
866 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
868 /* We have to clear the scroll bars, too. If we have changed
869 colors or something like that, then they should be notified. */
870 x_scroll_bar_clear (f
);
872 XFlush (FRAME_X_DISPLAY (f
));
877 /* This currently does not work because FRAME_CURRENT_GLYPHS doesn't
878 always contain the right glyphs to use.
880 It also needs to be changed to look at the details of the font and
881 see whether there is really overlap, and do nothing when there is
882 not. This can use font_char_overlap_left and font_char_overlap_right,
883 but just how to use them is not clear. */
885 /* Erase the character (if any) at the position just before X, Y in frame F,
886 then redraw it and the character before it.
887 This is necessary when we erase starting at X,
888 in case the character after X overlaps into the one before X.
889 Call this function with input blocked. */
892 redraw_previous_char (f
, x
, y
, highlight_flag
)
897 /* Erase the character before the new ones, in case
898 what was here before overlaps it.
899 Reoutput that character, and the previous character
900 (in case the previous character overlaps it). */
906 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
907 CHAR_TO_PIXEL_COL (f
, x
- 1),
908 CHAR_TO_PIXEL_ROW (f
, y
),
909 FONT_WIDTH (f
->output_data
.x
->font
),
910 f
->output_data
.x
->line_height
, False
);
912 dumpglyphs (f
, CHAR_TO_PIXEL_COL (f
, start_x
),
913 CHAR_TO_PIXEL_ROW (f
, y
),
914 &FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][start_x
],
915 x
- start_x
, highlight_flag
, 1);
919 /* Erase the character (if any) at the position X, Y in frame F,
920 then redraw it and the character after it.
921 This is necessary when we erase endng at X,
922 in case the character after X overlaps into the one before X.
923 Call this function with input blocked. */
926 redraw_following_char (f
, x
, y
, highlight_flag
)
931 int limit
= FRAME_CURRENT_GLYPHS (f
)->used
[y
];
932 /* Erase the character after the new ones, in case
933 what was here before overlaps it.
934 Reoutput that character, and the following character
935 (in case the following character overlaps it). */
937 && FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][x
] != SPACEGLYPH
)
942 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
943 CHAR_TO_PIXEL_COL (f
, x
),
944 CHAR_TO_PIXEL_ROW (f
, y
),
945 FONT_WIDTH (f
->output_data
.x
->font
),
946 f
->output_data
.x
->line_height
, False
);
948 dumpglyphs (f
, CHAR_TO_PIXEL_COL (f
, x
),
949 CHAR_TO_PIXEL_ROW (f
, y
),
950 &FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][x
],
951 end_x
- x
, highlight_flag
, 1);
956 #if 0 /* Not in use yet */
958 /* Return 1 if character C in font F extends past its left edge. */
961 font_char_overlap_left (font
, c
)
967 /* Find the bounding-box info for C. */
968 if (font
->per_char
== 0)
969 s
= &font
->max_bounds
;
972 int rowlen
= font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1;
975 /* Decode char into row number (byte 1) and code within row (byte 2). */
978 if (!(within
>= font
->min_char_or_byte2
979 && within
<= font
->max_char_or_byte2
980 && row
>= font
->min_byte1
981 && row
<= font
->max_byte1
))
983 /* If char is out of range, try the font's default char instead. */
984 c
= font
->default_char
;
985 row
= c
>> (BITS_PER_INT
- 8);
988 if (!(within
>= font
->min_char_or_byte2
989 && within
<= font
->max_char_or_byte2
990 && row
>= font
->min_byte1
991 && row
<= font
->max_byte1
))
992 /* Still out of range means this char does not overlap. */
995 /* We found the info for this char. */
996 s
= (font
->per_char
+ (within
- font
->min_char_or_byte2
)
1000 return (s
&& s
->lbearing
< 0);
1003 /* Return 1 if character C in font F extends past its right edge. */
1006 font_char_overlap_right (font
, c
)
1012 /* Find the bounding-box info for C. */
1013 if (font
->per_char
== 0)
1014 s
= &font
->max_bounds
;
1017 int rowlen
= font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1;
1020 /* Decode char into row number (byte 1) and code within row (byte 2). */
1023 if (!(within
>= font
->min_char_or_byte2
1024 && within
<= font
->max_char_or_byte2
1025 && row
>= font
->min_byte1
1026 && row
<= font
->max_byte1
))
1028 /* If char is out of range, try the font's default char instead. */
1029 c
= font
->default_char
;
1030 row
= c
>> (BITS_PER_INT
- 8);
1033 if (!(within
>= font
->min_char_or_byte2
1034 && within
<= font
->max_char_or_byte2
1035 && row
>= font
->min_byte1
1036 && row
<= font
->max_byte1
))
1037 /* Still out of range means this char does not overlap. */
1040 /* We found the info for this char. */
1041 s
= (font
->per_char
+ (within
- font
->min_char_or_byte2
)
1045 return (s
&& s
->rbearing
>= s
->width
);
1049 /* Invert the middle quarter of the frame for .15 sec. */
1051 /* We use the select system call to do the waiting, so we have to make sure
1052 it's available. If it isn't, we just won't do visual bells. */
1053 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
1055 /* Subtract the `struct timeval' values X and Y,
1056 storing the result in RESULT.
1057 Return 1 if the difference is negative, otherwise 0. */
1060 timeval_subtract (result
, x
, y
)
1061 struct timeval
*result
, x
, y
;
1063 /* Perform the carry for the later subtraction by updating y.
1064 This is safer because on some systems
1065 the tv_sec member is unsigned. */
1066 if (x
.tv_usec
< y
.tv_usec
)
1068 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
1069 y
.tv_usec
-= 1000000 * nsec
;
1072 if (x
.tv_usec
- y
.tv_usec
> 1000000)
1074 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
1075 y
.tv_usec
+= 1000000 * nsec
;
1079 /* Compute the time remaining to wait. tv_usec is certainly positive. */
1080 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
1081 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
1083 /* Return indication of whether the result should be considered negative. */
1084 return x
.tv_sec
< y
.tv_sec
;
1095 /* Create a GC that will use the GXxor function to flip foreground pixels
1096 into background pixels. */
1100 values
.function
= GXxor
;
1101 values
.foreground
= (f
->output_data
.x
->foreground_pixel
1102 ^ f
->output_data
.x
->background_pixel
);
1104 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1105 GCFunction
| GCForeground
, &values
);
1109 int width
= PIXEL_WIDTH (f
);
1110 int height
= PIXEL_HEIGHT (f
);
1112 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
1113 width
/4, height
/4, width
/2, height
/2);
1114 XFlush (FRAME_X_DISPLAY (f
));
1117 struct timeval wakeup
, now
;
1119 EMACS_GET_TIME (wakeup
);
1121 /* Compute time to wait until, propagating carry from usecs. */
1122 wakeup
.tv_usec
+= 150000;
1123 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
1124 wakeup
.tv_usec
%= 1000000;
1126 /* Keep waiting until past the time wakeup. */
1129 struct timeval timeout
;
1131 EMACS_GET_TIME (timeout
);
1133 /* In effect, timeout = wakeup - timeout.
1134 Break if result would be negative. */
1135 if (timeval_subtract (&timeout
, wakeup
, timeout
))
1138 /* Try to wait that long--but we might wake up sooner. */
1139 select (0, NULL
, NULL
, NULL
, &timeout
);
1143 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
1144 width
/4, height
/4, width
/2, height
/2);
1145 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
1146 XFlush (FRAME_X_DISPLAY (f
));
1156 /* Make audible bell. */
1158 #define XRINGBELL XBell (FRAME_X_DISPLAY (selected_frame), 0)
1162 if (FRAME_X_DISPLAY (selected_frame
) == 0)
1165 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
1167 XTflash (selected_frame
);
1173 XFlush (FRAME_X_DISPLAY (selected_frame
));
1178 /* Insert and delete character.
1179 These are not supposed to be used because we are supposed to turn
1180 off the feature of using them. */
1183 XTinsert_glyphs (start
, len
)
1184 register char *start
;
1197 /* Specify how many text lines, from the top of the window,
1198 should be affected by insert-lines and delete-lines operations.
1199 This, and those operations, are used only within an update
1200 that is bounded by calls to XTupdate_begin and XTupdate_end. */
1203 XTset_terminal_window (n
)
1206 if (updating_frame
== 0)
1209 if ((n
<= 0) || (n
> updating_frame
->height
))
1210 flexlines
= updating_frame
->height
;
1215 /* These variables need not be per frame
1216 because redisplay is done on a frame-by-frame basis
1217 and the line dance for one frame is finished before
1218 anything is done for anoter frame. */
1220 /* Array of line numbers from cached insert/delete operations.
1221 line_dance[i] is the old position of the line that we want
1222 to move to line i, or -1 if we want a blank line there. */
1223 static int *line_dance
;
1225 /* Allocated length of that array. */
1226 static int line_dance_len
;
1228 /* Flag indicating whether we've done any work. */
1229 static int line_dance_in_progress
;
1231 /* Perform an insert-lines or delete-lines operation,
1232 inserting N lines or deleting -N lines at vertical position VPOS. */
1233 XTins_del_lines (vpos
, n
)
1236 register int fence
, i
;
1238 if (vpos
>= flexlines
)
1241 if (!line_dance_in_progress
)
1243 int ht
= updating_frame
->height
;
1244 if (ht
> line_dance_len
)
1246 line_dance
= (int *)xrealloc (line_dance
, ht
* sizeof (int));
1247 line_dance_len
= ht
;
1249 for (i
= 0; i
< ht
; ++i
) line_dance
[i
] = i
;
1250 line_dance_in_progress
= 1;
1254 if (n
> flexlines
- vpos
)
1255 n
= flexlines
- vpos
;
1257 for (i
= flexlines
; --i
>= fence
;)
1258 line_dance
[i
] = line_dance
[i
-n
];
1259 for (i
= fence
; --i
>= vpos
;)
1265 if (n
> flexlines
- vpos
)
1266 n
= flexlines
- vpos
;
1267 fence
= flexlines
- n
;
1268 for (i
= vpos
; i
< fence
; ++i
)
1269 line_dance
[i
] = line_dance
[i
+ n
];
1270 for (i
= fence
; i
< flexlines
; ++i
)
1275 /* Here's where we actually move the pixels around.
1276 Must be called with input blocked. */
1280 register int i
, j
, distance
;
1281 register struct frame
*f
;
1285 /* Must check this flag first. If it's not set, then not only is the
1286 array uninitialized, but we might not even have a frame. */
1287 if (!line_dance_in_progress
)
1295 intborder
= f
->output_data
.x
->internal_border_width
;
1297 x_display_cursor (updating_frame
, 0);
1299 for (i
= 0; i
< ht
; ++i
)
1300 if (line_dance
[i
] != -1 && (distance
= line_dance
[i
]-i
) > 0)
1302 for (j
= i
; (j
< ht
&& line_dance
[j
] != -1
1303 && line_dance
[j
]-j
== distance
); ++j
);
1304 /* Copy [i,j) upward from [i+distance,j+distance) */
1305 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1306 FRAME_X_WINDOW (f
), f
->output_data
.x
->normal_gc
,
1307 intborder
, CHAR_TO_PIXEL_ROW (f
, i
+distance
),
1308 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1309 (j
-i
) * f
->output_data
.x
->line_height
,
1310 intborder
, CHAR_TO_PIXEL_ROW (f
, i
));
1314 for (i
= ht
; --i
>=0; )
1315 if (line_dance
[i
] != -1 && (distance
= line_dance
[i
]-i
) < 0)
1317 for (j
= i
; (--j
>= 0 && line_dance
[j
] != -1
1318 && line_dance
[j
]-j
== distance
););
1319 /* Copy (j,i] downward from (j+distance, i+distance] */
1320 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1321 FRAME_X_WINDOW (f
), f
->output_data
.x
->normal_gc
,
1322 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1+distance
),
1323 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1324 (i
-j
) * f
->output_data
.x
->line_height
,
1325 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1));
1329 for (i
= 0; i
< ht
; ++i
)
1330 if (line_dance
[i
] == -1)
1332 for (j
= i
; j
< ht
&& line_dance
[j
] == -1; ++j
);
1334 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1335 intborder
, CHAR_TO_PIXEL_ROW (f
, i
),
1336 f
->width
* FONT_WIDTH (f
->output_data
.x
->font
),
1337 (j
-i
) * f
->output_data
.x
->line_height
, False
);
1340 line_dance_in_progress
= 0;
1343 /* Support routines for exposure events. */
1344 static void clear_cursor ();
1346 /* Output into a rectangle of an X-window (for frame F)
1347 the characters in f->phys_lines that overlap that rectangle.
1348 TOP and LEFT are the position of the upper left corner of the rectangle.
1349 ROWS and COLS are the size of the rectangle.
1350 Call this function with input blocked. */
1353 dumprectangle (f
, left
, top
, cols
, rows
)
1355 register int left
, top
, cols
, rows
;
1357 register struct frame_glyphs
*active_frame
= FRAME_CURRENT_GLYPHS (f
);
1358 int cursor_cleared
= 0;
1362 if (FRAME_GARBAGED_P (f
))
1365 /* Express rectangle as four edges, instead of position-and-size. */
1366 bottom
= top
+ rows
;
1367 right
= left
+ cols
;
1369 /* Convert rectangle edges in pixels to edges in chars.
1370 Round down for left and top, up for right and bottom. */
1371 top
= PIXEL_TO_CHAR_ROW (f
, top
);
1372 left
= PIXEL_TO_CHAR_COL (f
, left
);
1373 bottom
+= (f
->output_data
.x
->line_height
- 1);
1374 right
+= (FONT_WIDTH (f
->output_data
.x
->font
) - 1);
1375 bottom
= PIXEL_TO_CHAR_ROW (f
, bottom
);
1376 right
= PIXEL_TO_CHAR_COL (f
, right
);
1378 /* Clip the rectangle to what can be visible. */
1383 if (right
> f
->width
)
1385 if (bottom
> f
->height
)
1388 /* Get size in chars of the rectangle. */
1389 cols
= right
- left
;
1390 rows
= bottom
- top
;
1392 /* If rectangle has zero area, return. */
1393 if (rows
<= 0) return;
1394 if (cols
<= 0) return;
1396 /* Turn off the cursor if it is in the rectangle.
1397 We will turn it back on afterward. */
1398 if ((f
->phys_cursor_x
>= left
) && (f
->phys_cursor_x
< right
)
1399 && (f
->phys_cursor_y
>= top
) && (f
->phys_cursor_y
< bottom
))
1405 /* Display the text in the rectangle, one text line at a time. */
1407 for (y
= top
; y
< bottom
; y
++)
1409 GLYPH
*line
= &active_frame
->glyphs
[y
][left
];
1411 if (! active_frame
->enable
[y
] || left
> active_frame
->used
[y
])
1415 CHAR_TO_PIXEL_COL (f
, left
),
1416 CHAR_TO_PIXEL_ROW (f
, y
),
1417 line
, min (cols
, active_frame
->used
[y
] - left
),
1418 active_frame
->highlight
[y
], 0);
1421 /* Turn the cursor on if we turned it off. */
1424 x_display_cursor (f
, 1);
1431 /* We used to only do this if Vx_no_window_manager was non-nil, but
1432 the ICCCM (section 4.1.6) says that the window's border pixmap
1433 and border pixel are window attributes which are "private to the
1434 client", so we can always change it to whatever we want. */
1436 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1437 f
->output_data
.x
->border_pixel
);
1439 x_update_cursor (f
, 1);
1443 frame_unhighlight (f
)
1446 /* We used to only do this if Vx_no_window_manager was non-nil, but
1447 the ICCCM (section 4.1.6) says that the window's border pixmap
1448 and border pixel are window attributes which are "private to the
1449 client", so we can always change it to whatever we want. */
1451 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1452 f
->output_data
.x
->border_tile
);
1454 x_update_cursor (f
, 1);
1457 static void XTframe_rehighlight ();
1458 static void x_frame_rehighlight ();
1460 /* The focus has changed. Update the frames as necessary to reflect
1461 the new situation. Note that we can't change the selected frame
1462 here, because the Lisp code we are interrupting might become confused.
1463 Each event gets marked with the frame in which it occurred, so the
1464 Lisp code can tell when the switch took place by examining the events. */
1467 x_new_focus_frame (dpyinfo
, frame
)
1468 struct x_display_info
*dpyinfo
;
1469 struct frame
*frame
;
1471 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
1472 int events_enqueued
= 0;
1474 if (frame
!= dpyinfo
->x_focus_frame
)
1476 /* Set this before calling other routines, so that they see
1477 the correct value of x_focus_frame. */
1478 dpyinfo
->x_focus_frame
= frame
;
1480 if (old_focus
&& old_focus
->auto_lower
)
1481 x_lower_frame (old_focus
);
1484 selected_frame
= frame
;
1485 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
1487 Fselect_window (selected_frame
->selected_window
);
1488 choose_minibuf_frame ();
1491 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
1492 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
1494 pending_autoraise_frame
= 0;
1497 x_frame_rehighlight (dpyinfo
);
1500 /* Handle an event saying the mouse has moved out of an Emacs frame. */
1503 x_mouse_leave (dpyinfo
)
1504 struct x_display_info
*dpyinfo
;
1506 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
1509 /* The focus has changed, or we have redirected a frame's focus to
1510 another frame (this happens when a frame uses a surrogate
1511 minibuffer frame). Shift the highlight as appropriate.
1513 The FRAME argument doesn't necessarily have anything to do with which
1514 frame is being highlighted or unhighlighted; we only use it to find
1515 the appropriate X display info. */
1517 XTframe_rehighlight (frame
)
1518 struct frame
*frame
;
1520 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
1524 x_frame_rehighlight (dpyinfo
)
1525 struct x_display_info
*dpyinfo
;
1527 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
1529 if (dpyinfo
->x_focus_frame
)
1531 dpyinfo
->x_highlight_frame
1532 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
1533 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
1534 : dpyinfo
->x_focus_frame
);
1535 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
1537 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
1538 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
1542 dpyinfo
->x_highlight_frame
= 0;
1544 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
1547 frame_unhighlight (old_highlight
);
1548 if (dpyinfo
->x_highlight_frame
)
1549 frame_highlight (dpyinfo
->x_highlight_frame
);
1553 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
1555 /* Initialize mode_switch_bit and modifier_meaning. */
1557 x_find_modifier_meanings (dpyinfo
)
1558 struct x_display_info
*dpyinfo
;
1560 int min_code
, max_code
;
1563 XModifierKeymap
*mods
;
1565 dpyinfo
->meta_mod_mask
= 0;
1566 dpyinfo
->shift_lock_mask
= 0;
1567 dpyinfo
->alt_mod_mask
= 0;
1568 dpyinfo
->super_mod_mask
= 0;
1569 dpyinfo
->hyper_mod_mask
= 0;
1572 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
1574 min_code
= dpyinfo
->display
->min_keycode
;
1575 max_code
= dpyinfo
->display
->max_keycode
;
1578 syms
= XGetKeyboardMapping (dpyinfo
->display
,
1579 min_code
, max_code
- min_code
+ 1,
1581 mods
= XGetModifierMapping (dpyinfo
->display
);
1583 /* Scan the modifier table to see which modifier bits the Meta and
1584 Alt keysyms are on. */
1586 int row
, col
; /* The row and column in the modifier table. */
1588 for (row
= 3; row
< 8; row
++)
1589 for (col
= 0; col
< mods
->max_keypermod
; col
++)
1592 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
1594 /* Zeroes are used for filler. Skip them. */
1598 /* Are any of this keycode's keysyms a meta key? */
1602 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
1604 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
1610 dpyinfo
->meta_mod_mask
|= (1 << row
);
1615 dpyinfo
->alt_mod_mask
|= (1 << row
);
1620 dpyinfo
->hyper_mod_mask
|= (1 << row
);
1625 dpyinfo
->super_mod_mask
|= (1 << row
);
1629 /* Ignore this if it's not on the lock modifier. */
1630 if ((1 << row
) == LockMask
)
1631 dpyinfo
->shift_lock_mask
= LockMask
;
1639 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
1640 if (! dpyinfo
->meta_mod_mask
)
1642 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
1643 dpyinfo
->alt_mod_mask
= 0;
1646 /* If some keys are both alt and meta,
1647 make them just meta, not alt. */
1648 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
1650 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
1653 XFree ((char *) syms
);
1654 XFreeModifiermap (mods
);
1657 /* Convert between the modifier bits X uses and the modifier bits
1660 x_x_to_emacs_modifiers (dpyinfo
, state
)
1661 struct x_display_info
*dpyinfo
;
1664 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
1665 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
1666 | ((state
& dpyinfo
->meta_mod_mask
) ? meta_modifier
: 0)
1667 | ((state
& dpyinfo
->alt_mod_mask
) ? alt_modifier
: 0)
1668 | ((state
& dpyinfo
->super_mod_mask
) ? super_modifier
: 0)
1669 | ((state
& dpyinfo
->hyper_mod_mask
) ? hyper_modifier
: 0));
1673 x_emacs_to_x_modifiers (dpyinfo
, state
)
1674 struct x_display_info
*dpyinfo
;
1677 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
1678 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
1679 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
1680 | ((state
& shift_modifier
) ? ShiftMask
: 0)
1681 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
1682 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
1685 /* Convert a keysym to its name. */
1688 x_get_keysym_name (keysym
)
1694 value
= XKeysymToString (keysym
);
1700 /* Mouse clicks and mouse movement. Rah. */
1702 /* Given a pixel position (PIX_X, PIX_Y) on the frame F, return
1703 glyph co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle
1704 that the glyph at X, Y occupies, if BOUNDS != 0.
1705 If NOCLIP is nonzero, do not force the value into range. */
1708 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
1710 register int pix_x
, pix_y
;
1711 register int *x
, *y
;
1715 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
1716 even for negative values. */
1718 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
1720 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
1722 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
1723 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
1727 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
1728 bounds
->height
= f
->output_data
.x
->line_height
;
1729 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
1730 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
1737 else if (pix_x
> f
->width
)
1742 else if (pix_y
> f
->height
)
1751 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
1754 register int *pix_x
, *pix_y
;
1756 *pix_x
= CHAR_TO_PIXEL_COL (f
, x
);
1757 *pix_y
= CHAR_TO_PIXEL_ROW (f
, y
);
1760 /* Prepare a mouse-event in *RESULT for placement in the input queue.
1762 If the event is a button press, then note that we have grabbed
1766 construct_mouse_click (result
, event
, f
)
1767 struct input_event
*result
;
1768 XButtonEvent
*event
;
1771 /* Make the event type no_event; we'll change that when we decide
1773 result
->kind
= mouse_click
;
1774 result
->code
= event
->button
- Button1
;
1775 result
->timestamp
= event
->time
;
1776 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
1778 | (event
->type
== ButtonRelease
1786 pixel_to_glyph_coords (f
, event
->x
, event
->y
, &column
, &row
, NULL
, 0);
1787 XSETFASTINT (result
->x
, column
);
1788 XSETFASTINT (result
->y
, row
);
1790 XSETINT (result
->x
, event
->x
);
1791 XSETINT (result
->y
, event
->y
);
1792 XSETFRAME (result
->frame_or_window
, f
);
1796 /* Prepare a menu-event in *RESULT for placement in the input queue. */
1799 construct_menu_click (result
, event
, f
)
1800 struct input_event
*result
;
1801 XButtonEvent
*event
;
1804 /* Make the event type no_event; we'll change that when we decide
1806 result
->kind
= mouse_click
;
1807 XSETINT (result
->code
, event
->button
- Button1
);
1808 result
->timestamp
= event
->time
;
1809 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
1811 | (event
->type
== ButtonRelease
1815 XSETINT (result
->x
, event
->x
);
1816 XSETINT (result
->y
, -1);
1817 XSETFRAME (result
->frame_or_window
, f
);
1820 /* Function to report a mouse movement to the mainstream Emacs code.
1821 The input handler calls this.
1823 We have received a mouse movement event, which is given in *event.
1824 If the mouse is over a different glyph than it was last time, tell
1825 the mainstream emacs code by setting mouse_moved. If not, ask for
1826 another motion event, so we can check again the next time it moves. */
1829 note_mouse_movement (frame
, event
)
1831 XMotionEvent
*event
;
1833 last_mouse_movement_time
= event
->time
;
1835 if (event
->window
!= FRAME_X_WINDOW (frame
))
1837 frame
->mouse_moved
= 1;
1838 last_mouse_scroll_bar
= Qnil
;
1840 note_mouse_highlight (frame
, -1, -1);
1843 /* Has the mouse moved off the glyph it was on at the last sighting? */
1844 else if (event
->x
< last_mouse_glyph
.x
1845 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
1846 || event
->y
< last_mouse_glyph
.y
1847 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
1849 frame
->mouse_moved
= 1;
1850 last_mouse_scroll_bar
= Qnil
;
1852 note_mouse_highlight (frame
, event
->x
, event
->y
);
1856 /* This is used for debugging, to turn off note_mouse_highlight. */
1857 static int disable_mouse_highlight
;
1859 /* Take proper action when the mouse has moved to position X, Y on frame F
1860 as regards highlighting characters that have mouse-face properties.
1861 Also dehighlighting chars where the mouse was before.
1862 X and Y can be negative or out of range. */
1865 note_mouse_highlight (f
, x
, y
)
1869 int row
, column
, portion
;
1870 XRectangle new_glyph
;
1874 if (disable_mouse_highlight
)
1877 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_x
= x
;
1878 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_y
= y
;
1879 FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
= f
;
1881 if (FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
)
1886 FRAME_X_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 1;
1890 /* Find out which glyph the mouse is on. */
1891 pixel_to_glyph_coords (f
, x
, y
, &column
, &row
,
1892 &new_glyph
, FRAME_X_DISPLAY_INFO (f
)->grabbed
);
1894 /* Which window is that in? */
1895 window
= window_from_coordinates (f
, column
, row
, &portion
);
1896 w
= XWINDOW (window
);
1898 /* If we were displaying active text in another window, clear that. */
1899 if (! EQ (window
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
))
1900 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1902 /* Are we in a window whose display is up to date?
1903 And verify the buffer's text has not changed. */
1904 if (WINDOWP (window
) && portion
== 0 && row
>= 0 && column
>= 0
1905 && row
< FRAME_HEIGHT (f
) && column
< FRAME_WIDTH (f
)
1906 && EQ (w
->window_end_valid
, w
->buffer
)
1907 && w
->last_modified
== BUF_MODIFF (XBUFFER (w
->buffer
)))
1909 int *ptr
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[row
];
1912 /* Find which buffer position the mouse corresponds to. */
1913 for (i
= column
; i
>= 0; i
--)
1917 /* Is it outside the displayed active region (if any)? */
1919 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1920 else if (! (EQ (window
, FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
)
1921 && row
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
1922 && row
<= FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
1923 && (row
> FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
1924 || column
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
)
1925 && (row
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
1926 || column
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
1927 || FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
)))
1929 Lisp_Object mouse_face
, overlay
, position
;
1930 Lisp_Object
*overlay_vec
;
1931 int len
, noverlays
, ignor1
;
1932 struct buffer
*obuf
;
1935 /* If we get an out-of-range value, return now; avoid an error. */
1936 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1939 /* Make the window's buffer temporarily current for
1940 overlays_at and compute_char_face. */
1941 obuf
= current_buffer
;
1942 current_buffer
= XBUFFER (w
->buffer
);
1948 /* Yes. Clear the display of the old active region, if any. */
1949 clear_mouse_face (FRAME_X_DISPLAY_INFO (f
));
1951 /* Is this char mouse-active? */
1952 XSETINT (position
, pos
);
1955 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1957 /* Put all the overlays we want in a vector in overlay_vec.
1958 Store the length in len. */
1959 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
1961 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1963 /* Find the highest priority overlay that has a mouse-face prop. */
1965 for (i
= 0; i
< noverlays
; i
++)
1967 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1968 if (!NILP (mouse_face
))
1970 overlay
= overlay_vec
[i
];
1975 /* If no overlay applies, get a text property. */
1977 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
1979 /* Handle the overlay case. */
1980 if (! NILP (overlay
))
1982 /* Find the range of text around this char that
1983 should be active. */
1984 Lisp_Object before
, after
;
1987 before
= Foverlay_start (overlay
);
1988 after
= Foverlay_end (overlay
);
1989 /* Record this as the current active region. */
1990 fast_find_position (window
, before
,
1991 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
,
1992 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
);
1993 FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
1994 = !fast_find_position (window
, after
,
1995 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
,
1996 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
);
1997 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= window
;
1998 FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
1999 = compute_char_face (f
, w
, pos
, 0, 0,
2000 &ignore
, pos
+ 1, 1);
2002 /* Display it as active. */
2003 show_mouse_face (FRAME_X_DISPLAY_INFO (f
), 1);
2005 /* Handle the text property case. */
2006 else if (! NILP (mouse_face
))
2008 /* Find the range of text around this char that
2009 should be active. */
2010 Lisp_Object before
, after
, beginning
, end
;
2013 beginning
= Fmarker_position (w
->start
);
2014 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
2015 - XFASTINT (w
->window_end_pos
)));
2017 = Fprevious_single_property_change (make_number (pos
+ 1),
2019 w
->buffer
, beginning
);
2021 = Fnext_single_property_change (position
, Qmouse_face
,
2023 /* Record this as the current active region. */
2024 fast_find_position (window
, before
,
2025 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
,
2026 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
);
2027 FRAME_X_DISPLAY_INFO (f
)->mouse_face_past_end
2028 = !fast_find_position (window
, after
,
2029 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
,
2030 &FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
);
2031 FRAME_X_DISPLAY_INFO (f
)->mouse_face_window
= window
;
2032 FRAME_X_DISPLAY_INFO (f
)->mouse_face_face_id
2033 = compute_char_face (f
, w
, pos
, 0, 0,
2034 &ignore
, pos
+ 1, 1);
2036 /* Display it as active. */
2037 show_mouse_face (FRAME_X_DISPLAY_INFO (f
), 1);
2041 current_buffer
= obuf
;
2046 /* Find the row and column of position POS in window WINDOW.
2047 Store them in *COLUMNP and *ROWP.
2048 This assumes display in WINDOW is up to date.
2049 If POS is above start of WINDOW, return coords
2050 of start of first screen line.
2051 If POS is after end of WINDOW, return coords of end of last screen line.
2053 Value is 1 if POS is in range, 0 if it was off screen. */
2056 fast_find_position (window
, pos
, columnp
, rowp
)
2059 int *columnp
, *rowp
;
2061 struct window
*w
= XWINDOW (window
);
2062 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2067 int height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
2068 int width
= window_internal_width (w
);
2071 int maybe_next_line
= 0;
2073 /* Find the right row. */
2078 int linestart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ i
][left
];
2079 if (linestart
> pos
)
2081 /* If the position sought is the end of the buffer,
2082 don't include the blank lines at the bottom of the window. */
2083 if (linestart
== pos
&& pos
== BUF_ZV (XBUFFER (w
->buffer
)))
2085 maybe_next_line
= 1;
2092 /* Find the right column with in it. */
2093 charstarts
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ row
];
2095 for (i
= 0; i
< width
; i
++)
2097 if (charstarts
[left
+ i
] == pos
)
2100 *columnp
= i
+ left
;
2103 else if (charstarts
[left
+ i
] > pos
)
2105 else if (charstarts
[left
+ i
] > 0)
2109 /* If we're looking for the end of the buffer,
2110 and we didn't find it in the line we scanned,
2111 use the start of the following line. */
2112 if (maybe_next_line
)
2123 /* Display the active region described by mouse_face_*
2124 in its mouse-face if HL > 0, in its normal face if HL = 0. */
2127 show_mouse_face (dpyinfo
, hl
)
2128 struct x_display_info
*dpyinfo
;
2131 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
2132 int width
= window_internal_width (w
);
2133 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2136 int old_curs_x
= curs_x
;
2137 int old_curs_y
= curs_y
;
2139 /* Set these variables temporarily
2140 so that if we have to turn the cursor off and on again
2141 we will put it back at the same place. */
2142 curs_x
= f
->phys_cursor_x
;
2143 curs_y
= f
->phys_cursor_y
;
2145 for (i
= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
;
2146 i
<= FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
; i
++)
2148 int column
= (i
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
2149 ? FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
2151 int endcolumn
= (i
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
2152 ? FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
2154 endcolumn
= min (endcolumn
, FRAME_CURRENT_GLYPHS (f
)->used
[i
]);
2156 /* If the cursor's in the text we are about to rewrite,
2157 turn the cursor off. */
2159 && curs_x
>= column
- 1
2160 && curs_x
<= endcolumn
)
2162 x_display_cursor (f
, 0);
2167 CHAR_TO_PIXEL_COL (f
, column
),
2168 CHAR_TO_PIXEL_ROW (f
, i
),
2169 FRAME_CURRENT_GLYPHS (f
)->glyphs
[i
] + column
,
2171 /* Highlight with mouse face if hl > 0. */
2175 /* If we turned the cursor off, turn it back on. */
2177 x_display_cursor (f
, 1);
2179 curs_x
= old_curs_x
;
2180 curs_y
= old_curs_y
;
2182 /* Change the mouse cursor according to the value of HL. */
2184 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2185 f
->output_data
.x
->cross_cursor
);
2187 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2188 f
->output_data
.x
->text_cursor
);
2191 /* Clear out the mouse-highlighted active region.
2192 Redraw it unhighlighted first. */
2195 clear_mouse_face (dpyinfo
)
2196 struct x_display_info
*dpyinfo
;
2198 if (! NILP (dpyinfo
->mouse_face_window
))
2199 show_mouse_face (dpyinfo
, 0);
2201 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
2202 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
2203 dpyinfo
->mouse_face_window
= Qnil
;
2206 static struct scroll_bar
*x_window_to_scroll_bar ();
2207 static void x_scroll_bar_report_motion ();
2209 /* Return the current position of the mouse.
2210 *fp should be a frame which indicates which display to ask about.
2212 If the mouse movement started in a scroll bar, set *fp, *bar_window,
2213 and *part to the frame, window, and scroll bar part that the mouse
2214 is over. Set *x and *y to the portion and whole of the mouse's
2215 position on the scroll bar.
2217 If the mouse movement started elsewhere, set *fp to the frame the
2218 mouse is on, *bar_window to nil, and *x and *y to the character cell
2221 Set *time to the server timestamp for the time at which the mouse
2222 was at this position.
2224 Don't store anything if we don't have a valid set of values to report.
2226 This clears the mouse_moved flag, so we can wait for the next mouse
2230 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
2233 Lisp_Object
*bar_window
;
2234 enum scroll_bar_part
*part
;
2236 unsigned long *time
;
2242 if (! NILP (last_mouse_scroll_bar
))
2243 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
2249 Window dummy_window
;
2252 Lisp_Object frame
, tail
;
2254 /* Clear the mouse-moved flag for every frame on this display. */
2255 FOR_EACH_FRAME (tail
, frame
)
2256 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
2257 XFRAME (frame
)->mouse_moved
= 0;
2259 last_mouse_scroll_bar
= Qnil
;
2261 /* Figure out which root window we're on. */
2262 XQueryPointer (FRAME_X_DISPLAY (*fp
),
2263 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
2265 /* The root window which contains the pointer. */
2268 /* Trash which we can't trust if the pointer is on
2269 a different screen. */
2272 /* The position on that root window. */
2275 /* More trash we can't trust. */
2278 /* Modifier keys and pointer buttons, about which
2280 (unsigned int *) &dummy
);
2282 /* Now we have a position on the root; find the innermost window
2283 containing the pointer. */
2287 int parent_x
, parent_y
;
2291 /* XTranslateCoordinates can get errors if the window
2292 structure is changing at the same time this function
2293 is running. So at least we must not crash from them. */
2295 x_catch_errors (FRAME_X_DISPLAY (*fp
));
2297 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
2298 && FRAME_LIVE_P (last_mouse_frame
))
2300 /* If mouse was grabbed on a frame, give coords for that frame
2301 even if the mouse is now outside it. */
2302 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
2304 /* From-window, to-window. */
2305 root
, FRAME_X_WINDOW (last_mouse_frame
),
2307 /* From-position, to-position. */
2308 root_x
, root_y
, &win_x
, &win_y
,
2312 f1
= last_mouse_frame
;
2318 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
2320 /* From-window, to-window. */
2323 /* From-position, to-position. */
2324 root_x
, root_y
, &win_x
, &win_y
,
2329 if (child
== None
|| child
== win
)
2337 /* Now we know that:
2338 win is the innermost window containing the pointer
2339 (XTC says it has no child containing the pointer),
2340 win_x and win_y are the pointer's position in it
2341 (XTC did this the last time through), and
2342 parent_x and parent_y are the pointer's position in win's parent.
2343 (They are what win_x and win_y were when win was child.
2344 If win is the root window, it has no parent, and
2345 parent_{x,y} are invalid, but that's okay, because we'll
2346 never use them in that case.) */
2348 /* Is win one of our frames? */
2349 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
2352 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
2355 x_uncatch_errors (FRAME_X_DISPLAY (*fp
));
2357 /* If not, is it one of our scroll bars? */
2360 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
2364 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2370 if (f1
== 0 && insist
)
2371 f1
= selected_frame
;
2375 int ignore1
, ignore2
;
2377 /* Ok, we found a frame. Store all the values. */
2379 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
2381 FRAME_X_DISPLAY_INFO (f1
)->grabbed
2387 XSETINT (*x
, win_x
);
2388 XSETINT (*y
, win_y
);
2389 *time
= last_mouse_movement_time
;
2397 /* Scroll bar support. */
2399 /* Given an X window ID, find the struct scroll_bar which manages it.
2400 This can be called in GC, so we have to make sure to strip off mark
2402 static struct scroll_bar
*
2403 x_window_to_scroll_bar (window_id
)
2406 Lisp_Object tail
, frame
;
2408 for (tail
= Vframe_list
;
2409 XGCTYPE (tail
) == Lisp_Cons
;
2410 tail
= XCONS (tail
)->cdr
)
2412 Lisp_Object frame
, bar
, condemned
;
2414 frame
= XCONS (tail
)->car
;
2415 /* All elements of Vframe_list should be frames. */
2416 if (! GC_FRAMEP (frame
))
2419 /* Scan this frame's scroll bar list for a scroll bar with the
2421 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
2422 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
2423 /* This trick allows us to search both the ordinary and
2424 condemned scroll bar lists with one loop. */
2425 ! GC_NILP (bar
) || (bar
= condemned
,
2428 bar
= XSCROLL_BAR (bar
)->next
)
2429 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
2430 return XSCROLL_BAR (bar
);
2436 /* Open a new X window to serve as a scroll bar, and return the
2437 scroll bar vector for it. */
2438 static struct scroll_bar
*
2439 x_scroll_bar_create (window
, top
, left
, width
, height
)
2440 struct window
*window
;
2441 int top
, left
, width
, height
;
2443 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2444 struct scroll_bar
*bar
2445 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
2450 XSetWindowAttributes a
;
2452 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
2453 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
2454 | ButtonMotionMask
| PointerMotionHintMask
2456 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
2458 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
2463 XtSetArg (al
[ac
], XtNx
, left
); ac
++;
2464 XtSetArg (al
[ac
], XtNy
, top
); ac
++;
2465 XtSetArg (al
[ac
], XtNwidth
, width
); ac
++;
2466 XtSetArg (al
[ac
], XtNheight
, height
); ac
++;
2467 XtSetArg (al
[ac
], XtNborderWidth
, 0); ac
++;
2468 sb_widget
= XtCreateManagedWidget ("box",
2470 f
->output_data
.x
->edit_widget
, al
, ac
);
2471 SET_SCROLL_BAR_X_WINDOW
2472 (bar
, sb_widget
->core
.window
);
2474 SET_SCROLL_BAR_X_WINDOW
2476 XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2478 /* Position and size of scroll bar. */
2479 left
, top
, width
, height
,
2481 /* Border width, depth, class, and visual. */
2482 0, CopyFromParent
, CopyFromParent
, CopyFromParent
,
2488 XSETWINDOW (bar
->window
, window
);
2489 XSETINT (bar
->top
, top
);
2490 XSETINT (bar
->left
, left
);
2491 XSETINT (bar
->width
, width
);
2492 XSETINT (bar
->height
, height
);
2493 XSETINT (bar
->start
, 0);
2494 XSETINT (bar
->end
, 0);
2495 bar
->dragging
= Qnil
;
2497 /* Add bar to its frame's list of scroll bars. */
2498 bar
->next
= FRAME_SCROLL_BARS (f
);
2500 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2501 if (! NILP (bar
->next
))
2502 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2504 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
2511 /* Draw BAR's handle in the proper position.
2512 If the handle is already drawn from START to END, don't bother
2513 redrawing it, unless REBUILD is non-zero; in that case, always
2514 redraw it. (REBUILD is handy for drawing the handle after expose
2517 Normally, we want to constrain the start and end of the handle to
2518 fit inside its rectangle, but if the user is dragging the scroll bar
2519 handle, we want to let them drag it down all the way, so that the
2520 bar's top is as far down as it goes; otherwise, there's no way to
2521 move to the very end of the buffer. */
2523 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
2524 struct scroll_bar
*bar
;
2528 int dragging
= ! NILP (bar
->dragging
);
2529 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2530 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2531 GC gc
= f
->output_data
.x
->normal_gc
;
2533 /* If the display is already accurate, do nothing. */
2535 && start
== XINT (bar
->start
)
2536 && end
== XINT (bar
->end
))
2542 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (XINT (bar
->width
));
2543 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2544 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2546 /* Make sure the values are reasonable, and try to preserve
2547 the distance between start and end. */
2549 int length
= end
- start
;
2553 else if (start
> top_range
)
2555 end
= start
+ length
;
2559 else if (end
> top_range
&& ! dragging
)
2563 /* Store the adjusted setting in the scroll bar. */
2564 XSETINT (bar
->start
, start
);
2565 XSETINT (bar
->end
, end
);
2567 /* Clip the end position, just for display. */
2568 if (end
> top_range
)
2571 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
2572 below top positions, to make sure the handle is always at least
2573 that many pixels tall. */
2574 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
2576 /* Draw the empty space above the handle. Note that we can't clear
2577 zero-height areas; that means "clear to end of window." */
2579 XClearArea (FRAME_X_DISPLAY (f
), w
,
2581 /* x, y, width, height, and exposures. */
2582 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2583 VERTICAL_SCROLL_BAR_TOP_BORDER
,
2584 inside_width
, start
,
2587 /* Draw the handle itself. */
2588 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
2590 /* x, y, width, height */
2591 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2592 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
2593 inside_width
, end
- start
);
2596 /* Draw the empty space below the handle. Note that we can't
2597 clear zero-height areas; that means "clear to end of window." */
2598 if (end
< inside_height
)
2599 XClearArea (FRAME_X_DISPLAY (f
), w
,
2601 /* x, y, width, height, and exposures. */
2602 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2603 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
2604 inside_width
, inside_height
- end
,
2612 /* Move a scroll bar around on the screen, to accommodate changing
2613 window configurations. */
2615 x_scroll_bar_move (bar
, top
, left
, width
, height
)
2616 struct scroll_bar
*bar
;
2617 int top
, left
, width
, height
;
2619 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2620 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2626 unsigned int mask
= 0;
2633 if (left
!= XINT (bar
->left
)) mask
|= CWX
;
2634 if (top
!= XINT (bar
->top
)) mask
|= CWY
;
2635 if (width
!= XINT (bar
->width
)) mask
|= CWWidth
;
2636 if (height
!= XINT (bar
->height
)) mask
|= CWHeight
;
2639 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
2643 XSETINT (bar
->left
, left
);
2644 XSETINT (bar
->top
, top
);
2645 XSETINT (bar
->width
, width
);
2646 XSETINT (bar
->height
, height
);
2651 /* Destroy the X window for BAR, and set its Emacs window's scroll bar
2654 x_scroll_bar_remove (bar
)
2655 struct scroll_bar
*bar
;
2657 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2661 /* Destroy the window. */
2662 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
2664 /* Disassociate this scroll bar from its window. */
2665 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
2670 /* Set the handle of the vertical scroll bar for WINDOW to indicate
2671 that we are displaying PORTION characters out of a total of WHOLE
2672 characters, starting at POSITION. If WINDOW has no scroll bar,
2675 XTset_vertical_scroll_bar (window
, portion
, whole
, position
)
2676 struct window
*window
;
2677 int portion
, whole
, position
;
2679 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2680 int top
= XINT (window
->top
);
2681 int left
= WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window
);
2682 int height
= WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window
);
2684 /* Where should this scroll bar be, pixelwise? */
2685 int pixel_top
= CHAR_TO_PIXEL_ROW (f
, top
);
2686 int pixel_left
= CHAR_TO_PIXEL_COL (f
, left
);
2688 = (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
2689 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
2690 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
2691 int pixel_height
= VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f
, height
);
2693 struct scroll_bar
*bar
;
2695 /* Does the scroll bar exist yet? */
2696 if (NILP (window
->vertical_scroll_bar
))
2697 bar
= x_scroll_bar_create (window
,
2698 pixel_top
, pixel_left
,
2699 pixel_width
, pixel_height
);
2702 /* It may just need to be moved and resized. */
2703 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2704 x_scroll_bar_move (bar
, pixel_top
, pixel_left
, pixel_width
, pixel_height
);
2707 /* Set the scroll bar's current state, unless we're currently being
2709 if (NILP (bar
->dragging
))
2711 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height
);
2714 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
2717 int start
= ((double) position
* top_range
) / whole
;
2718 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
2720 x_scroll_bar_set_handle (bar
, start
, end
, 0);
2724 XSETVECTOR (window
->vertical_scroll_bar
, bar
);
2728 /* The following three hooks are used when we're doing a thorough
2729 redisplay of the frame. We don't explicitly know which scroll bars
2730 are going to be deleted, because keeping track of when windows go
2731 away is a real pain - "Can you say set-window-configuration, boys
2732 and girls?" Instead, we just assert at the beginning of redisplay
2733 that *all* scroll bars are to be removed, and then save a scroll bar
2734 from the fiery pit when we actually redisplay its window. */
2736 /* Arrange for all scroll bars on FRAME to be removed at the next call
2737 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
2738 `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
2740 XTcondemn_scroll_bars (frame
)
2743 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
2744 while (! NILP (FRAME_SCROLL_BARS (frame
)))
2747 bar
= FRAME_SCROLL_BARS (frame
);
2748 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
2749 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
2750 XSCROLL_BAR (bar
)->prev
= Qnil
;
2751 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
2752 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
2753 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
2757 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
2758 Note that WINDOW isn't necessarily condemned at all. */
2760 XTredeem_scroll_bar (window
)
2761 struct window
*window
;
2763 struct scroll_bar
*bar
;
2765 /* We can't redeem this window's scroll bar if it doesn't have one. */
2766 if (NILP (window
->vertical_scroll_bar
))
2769 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2771 /* Unlink it from the condemned list. */
2773 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2775 if (NILP (bar
->prev
))
2777 /* If the prev pointer is nil, it must be the first in one of
2779 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
2780 /* It's not condemned. Everything's fine. */
2782 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
2783 window
->vertical_scroll_bar
))
2784 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
2786 /* If its prev pointer is nil, it must be at the front of
2787 one or the other! */
2791 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
2793 if (! NILP (bar
->next
))
2794 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
2796 bar
->next
= FRAME_SCROLL_BARS (f
);
2798 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2799 if (! NILP (bar
->next
))
2800 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2804 /* Remove all scroll bars on FRAME that haven't been saved since the
2805 last call to `*condemn_scroll_bars_hook'. */
2807 XTjudge_scroll_bars (f
)
2810 Lisp_Object bar
, next
;
2812 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
2814 /* Clear out the condemned list now so we won't try to process any
2815 more events on the hapless scroll bars. */
2816 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
2818 for (; ! NILP (bar
); bar
= next
)
2820 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
2822 x_scroll_bar_remove (b
);
2825 b
->next
= b
->prev
= Qnil
;
2828 /* Now there should be no references to the condemned scroll bars,
2829 and they should get garbage-collected. */
2833 /* Handle an Expose or GraphicsExpose event on a scroll bar.
2835 This may be called from a signal handler, so we have to ignore GC
2838 x_scroll_bar_expose (bar
, event
)
2839 struct scroll_bar
*bar
;
2842 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2843 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2844 GC gc
= f
->output_data
.x
->normal_gc
;
2848 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
2850 /* Draw a one-pixel border just inside the edges of the scroll bar. */
2851 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
2853 /* x, y, width, height */
2854 0, 0, XINT (bar
->width
) - 1, XINT (bar
->height
) - 1);
2859 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
2860 is set to something other than no_event, it is enqueued.
2862 This may be called from a signal handler, so we have to ignore GC
2865 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
2866 struct scroll_bar
*bar
;
2868 struct input_event
*emacs_event
;
2870 if (! GC_WINDOWP (bar
->window
))
2873 emacs_event
->kind
= scroll_bar_click
;
2874 emacs_event
->code
= event
->xbutton
.button
- Button1
;
2875 emacs_event
->modifiers
2876 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
2877 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
2878 event
->xbutton
.state
)
2879 | (event
->type
== ButtonRelease
2882 emacs_event
->frame_or_window
= bar
->window
;
2883 emacs_event
->timestamp
= event
->xbutton
.time
;
2886 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2888 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2889 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
2892 if (y
> top_range
) y
= top_range
;
2894 if (y
< XINT (bar
->start
))
2895 emacs_event
->part
= scroll_bar_above_handle
;
2896 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
2897 emacs_event
->part
= scroll_bar_handle
;
2899 emacs_event
->part
= scroll_bar_below_handle
;
2901 /* Just because the user has clicked on the handle doesn't mean
2902 they want to drag it. Lisp code needs to be able to decide
2903 whether or not we're dragging. */
2905 /* If the user has just clicked on the handle, record where they're
2907 if (event
->type
== ButtonPress
2908 && emacs_event
->part
== scroll_bar_handle
)
2909 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
2912 /* If the user has released the handle, set it to its final position. */
2913 if (event
->type
== ButtonRelease
2914 && ! NILP (bar
->dragging
))
2916 int new_start
= y
- XINT (bar
->dragging
);
2917 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2919 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2920 bar
->dragging
= Qnil
;
2923 /* Same deal here as the other #if 0. */
2925 /* Clicks on the handle are always reported as occurring at the top of
2927 if (emacs_event
->part
== scroll_bar_handle
)
2928 emacs_event
->x
= bar
->start
;
2930 XSETINT (emacs_event
->x
, y
);
2932 XSETINT (emacs_event
->x
, y
);
2935 XSETINT (emacs_event
->y
, top_range
);
2939 /* Handle some mouse motion while someone is dragging the scroll bar.
2941 This may be called from a signal handler, so we have to ignore GC
2944 x_scroll_bar_note_movement (bar
, event
)
2945 struct scroll_bar
*bar
;
2948 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
2950 last_mouse_movement_time
= event
->xmotion
.time
;
2953 XSETVECTOR (last_mouse_scroll_bar
, bar
);
2955 /* If we're dragging the bar, display it. */
2956 if (! GC_NILP (bar
->dragging
))
2958 /* Where should the handle be now? */
2959 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
2961 if (new_start
!= XINT (bar
->start
))
2963 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2965 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2970 /* Return information to the user about the current position of the mouse
2971 on the scroll bar. */
2973 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
2975 Lisp_Object
*bar_window
;
2976 enum scroll_bar_part
*part
;
2978 unsigned long *time
;
2980 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
2981 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2982 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2984 Window dummy_window
;
2986 unsigned int dummy_mask
;
2990 /* Get the mouse's position relative to the scroll bar window, and
2992 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
2994 /* Root, child, root x and root y. */
2995 &dummy_window
, &dummy_window
,
2996 &dummy_coord
, &dummy_coord
,
2998 /* Position relative to scroll bar. */
3001 /* Mouse buttons and modifier keys. */
3007 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
3009 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
3011 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
3013 if (! NILP (bar
->dragging
))
3014 win_y
-= XINT (bar
->dragging
);
3018 if (win_y
> top_range
)
3022 *bar_window
= bar
->window
;
3024 if (! NILP (bar
->dragging
))
3025 *part
= scroll_bar_handle
;
3026 else if (win_y
< XINT (bar
->start
))
3027 *part
= scroll_bar_above_handle
;
3028 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
3029 *part
= scroll_bar_handle
;
3031 *part
= scroll_bar_below_handle
;
3033 XSETINT (*x
, win_y
);
3034 XSETINT (*y
, top_range
);
3037 last_mouse_scroll_bar
= Qnil
;
3040 *time
= last_mouse_movement_time
;
3046 /* The screen has been cleared so we may have changed foreground or
3047 background colors, and the scroll bars may need to be redrawn.
3048 Clear out the scroll bars, and ask for expose events, so we can
3051 x_scroll_bar_clear (f
)
3056 /* We can have scroll bars even if this is 0,
3057 if we just turned off scroll bar mode.
3058 But in that case we should not clear them. */
3059 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3060 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
3061 bar
= XSCROLL_BAR (bar
)->next
)
3062 XClearArea (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
3066 /* This processes Expose events from the menubar specific X event
3067 loop in xmenu.c. This allows to redisplay the frame if necessary
3068 when handling menubar or popup items. */
3071 process_expose_from_menu (event
)
3075 struct x_display_info
*dpyinfo
;
3079 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
3080 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
3083 if (f
->async_visible
== 0)
3085 f
->async_visible
= 1;
3086 f
->async_iconified
= 0;
3087 SET_FRAME_GARBAGED (f
);
3091 dumprectangle (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
3092 event
.xexpose
.x
, event
.xexpose
.y
,
3093 event
.xexpose
.width
, event
.xexpose
.height
);
3098 struct scroll_bar
*bar
3099 = x_window_to_scroll_bar (event
.xexpose
.window
);
3102 x_scroll_bar_expose (bar
, &event
);
3108 /* Define a queue to save up SelectionRequest events for later handling. */
3110 struct selection_event_queue
3113 struct selection_event_queue
*next
;
3116 static struct selection_event_queue
*queue
;
3118 /* Nonzero means queue up certain events--don't process them yet. */
3119 static int x_queue_selection_requests
;
3121 /* Queue up an X event *EVENT, to be processed later. */
3124 x_queue_event (f
, event
)
3128 struct selection_event_queue
*queue_tmp
3129 = (struct selection_event_queue
*) malloc (sizeof (struct selection_event_queue
));
3131 if (queue_tmp
!= NULL
)
3133 queue_tmp
->event
= *event
;
3134 queue_tmp
->next
= queue
;
3139 /* Take all the queued events and put them back
3140 so that they get processed afresh. */
3143 x_unqueue_events (display
)
3146 while (queue
!= NULL
)
3148 struct selection_event_queue
*queue_tmp
= queue
;
3149 XPutBackEvent (display
, &queue_tmp
->event
);
3150 queue
= queue_tmp
->next
;
3151 free ((char *)queue_tmp
);
3155 /* Start queuing SelectionRequest events. */
3158 x_start_queuing_selection_requests (display
)
3161 x_queue_selection_requests
++;
3164 /* Stop queuing SelectionRequest events. */
3167 x_stop_queuing_selection_requests (display
)
3170 x_queue_selection_requests
--;
3171 x_unqueue_events (display
);
3174 /* The main X event-reading loop - XTread_socket. */
3176 /* Timestamp of enter window event. This is only used by XTread_socket,
3177 but we have to put it out here, since static variables within functions
3178 sometimes don't work. */
3179 static Time enter_timestamp
;
3181 /* This holds the state XLookupString needs to implement dead keys
3182 and other tricks known as "compose processing". _X Window System_
3183 says that a portable program can't use this, but Stephen Gildea assures
3184 me that letting the compiler initialize it to zeros will work okay.
3186 This must be defined outside of XTread_socket, for the same reasons
3187 given for enter_timestamp, above. */
3188 static XComposeStatus compose_status
;
3190 /* Record the last 100 characters stored
3191 to help debug the loss-of-chars-during-GC problem. */
3192 static int temp_index
;
3193 static short temp_buffer
[100];
3195 /* Set this to nonzero to fake an "X I/O error"
3196 on a particular display. */
3197 struct x_display_info
*XTread_socket_fake_io_error
;
3199 /* When we find no input here, we occasionally do a no-op command
3200 to verify that the X server is still running and we can still talk with it.
3201 We try all the open displays, one by one.
3202 This variable is used for cycling thru the displays. */
3203 static struct x_display_info
*next_noop_dpyinfo
;
3205 /* Read events coming from the X server.
3206 This routine is called by the SIGIO handler.
3207 We return as soon as there are no more events to be read.
3209 Events representing keys are stored in buffer BUFP,
3210 which can hold up to NUMCHARS characters.
3211 We return the number of characters stored into the buffer,
3212 thus pretending to be `read'.
3214 WAITP is nonzero if we should block until input arrives.
3215 EXPECTED is nonzero if the caller knows input is available. */
3218 XTread_socket (sd
, bufp
, numchars
, waitp
, expected
)
3220 register struct input_event
*bufp
;
3221 register int numchars
;
3228 int items_pending
; /* How many items are in the X queue. */
3231 int event_found
= 0;
3234 struct x_display_info
*dpyinfo
;
3236 Status status_return
;
3239 if (interrupt_input_blocked
)
3241 interrupt_input_pending
= 1;
3245 interrupt_input_pending
= 0;
3248 /* So people can tell when we have read the available input. */
3249 input_signal_count
++;
3252 abort (); /* Don't think this happens. */
3254 /* Find the display we are supposed to read input for.
3255 It's the one communicating on descriptor SD. */
3256 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
3258 #if 0 /* This ought to be unnecessary; let's verify it. */
3260 /* If available, Xlib uses FIOSNBIO to make the socket
3261 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
3262 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
3263 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
3264 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
3265 #endif /* ! defined (FIOSNBIO) */
3268 #if 0 /* This code can't be made to work, with multiple displays,
3269 and appears not to be used on any system any more.
3270 Also keyboard.c doesn't turn O_NDELAY on and off
3271 for X connections. */
3274 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
3276 extern int read_alarm_should_throw
;
3277 read_alarm_should_throw
= 1;
3278 XPeekEvent (dpyinfo
->display
, &event
);
3279 read_alarm_should_throw
= 0;
3281 #endif /* HAVE_SELECT */
3285 /* For debugging, this gives a way to fake an I/O error. */
3286 if (dpyinfo
== XTread_socket_fake_io_error
)
3288 XTread_socket_fake_io_error
= 0;
3289 x_io_error_quitter (dpyinfo
->display
);
3292 while (XPending (dpyinfo
->display
) != 0)
3294 XNextEvent (dpyinfo
->display
, &event
);
3301 if (event
.xclient
.message_type
3302 == dpyinfo
->Xatom_wm_protocols
3303 && event
.xclient
.format
== 32)
3305 if (event
.xclient
.data
.l
[0]
3306 == dpyinfo
->Xatom_wm_take_focus
)
3308 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
3309 /* Since we set WM_TAKE_FOCUS, we must call
3310 XSetInputFocus explicitly. But not if f is null,
3311 since that might be an event for a deleted frame. */
3313 /* Not quite sure this is needed -pd */
3315 XSetICFocus (FRAME_XIC (f
));
3318 XSetInputFocus (event
.xclient
.display
,
3319 event
.xclient
.window
,
3320 RevertToPointerRoot
,
3321 event
.xclient
.data
.l
[1]);
3322 /* Not certain about handling scroll bars here */
3324 else if (event
.xclient
.data
.l
[0]
3325 == dpyinfo
->Xatom_wm_save_yourself
)
3327 /* Save state modify the WM_COMMAND property to
3328 something which can reinstate us. This notifies
3329 the session manager, who's looking for such a
3330 PropertyNotify. Can restart processing when
3331 a keyboard or mouse event arrives. */
3334 f
= x_top_window_to_frame (dpyinfo
,
3335 event
.xclient
.window
);
3337 /* This is just so we only give real data once
3338 for a single Emacs process. */
3339 if (f
== selected_frame
)
3340 XSetCommand (FRAME_X_DISPLAY (f
),
3341 event
.xclient
.window
,
3342 initial_argv
, initial_argc
);
3344 XSetCommand (FRAME_X_DISPLAY (f
),
3345 event
.xclient
.window
,
3349 else if (event
.xclient
.data
.l
[0]
3350 == dpyinfo
->Xatom_wm_delete_window
)
3353 = x_any_window_to_frame (dpyinfo
,
3354 event
.xclient
.window
);
3361 bufp
->kind
= delete_window_event
;
3362 XSETFRAME (bufp
->frame_or_window
, f
);
3370 else if (event
.xclient
.message_type
3371 == dpyinfo
->Xatom_wm_configure_denied
)
3374 else if (event
.xclient
.message_type
3375 == dpyinfo
->Xatom_wm_window_moved
)
3379 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
3381 new_x
= event
.xclient
.data
.s
[0];
3382 new_y
= event
.xclient
.data
.s
[1];
3386 f
->output_data
.x
->left_pos
= new_x
;
3387 f
->output_data
.x
->top_pos
= new_y
;
3391 else if (event
.xclient
.message_type
3392 == dpyinfo
->Xatom_editres
)
3395 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
3396 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
3399 #endif /* HACK_EDITRES */
3403 case SelectionNotify
:
3404 #ifdef USE_X_TOOLKIT
3405 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
3407 #endif /* not USE_X_TOOLKIT */
3408 x_handle_selection_notify (&event
);
3411 case SelectionClear
: /* Someone has grabbed ownership. */
3412 #ifdef USE_X_TOOLKIT
3413 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
3415 #endif /* USE_X_TOOLKIT */
3417 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
3422 bufp
->kind
= selection_clear_event
;
3423 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3424 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3425 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3426 bufp
->frame_or_window
= Qnil
;
3434 case SelectionRequest
: /* Someone wants our selection. */
3435 #ifdef USE_X_TOOLKIT
3436 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
3438 #endif /* USE_X_TOOLKIT */
3439 if (x_queue_selection_requests
)
3440 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
3444 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
3449 bufp
->kind
= selection_request_event
;
3450 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3451 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
3452 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3453 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
3454 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
3455 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3456 bufp
->frame_or_window
= Qnil
;
3464 case PropertyNotify
:
3465 #ifdef USE_X_TOOLKIT
3466 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
3468 #endif /* not USE_X_TOOLKIT */
3469 x_handle_property_notify (&event
);
3472 case ReparentNotify
:
3473 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
3477 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
3478 x_real_positions (f
, &x
, &y
);
3479 f
->output_data
.x
->left_pos
= x
;
3480 f
->output_data
.x
->top_pos
= y
;
3485 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
3488 if (f
->async_visible
== 0)
3490 f
->async_visible
= 1;
3491 f
->async_iconified
= 0;
3492 SET_FRAME_GARBAGED (f
);
3495 dumprectangle (x_window_to_frame (dpyinfo
,
3496 event
.xexpose
.window
),
3497 event
.xexpose
.x
, event
.xexpose
.y
,
3498 event
.xexpose
.width
, event
.xexpose
.height
);
3502 struct scroll_bar
*bar
3503 = x_window_to_scroll_bar (event
.xexpose
.window
);
3506 x_scroll_bar_expose (bar
, &event
);
3507 #ifdef USE_X_TOOLKIT
3510 #endif /* USE_X_TOOLKIT */
3514 case GraphicsExpose
: /* This occurs when an XCopyArea's
3515 source area was obscured or not
3517 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
3521 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
3522 event
.xgraphicsexpose
.width
,
3523 event
.xgraphicsexpose
.height
);
3525 #ifdef USE_X_TOOLKIT
3528 #endif /* USE_X_TOOLKIT */
3531 case NoExpose
: /* This occurs when an XCopyArea's
3532 source area was completely
3537 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
3538 if (f
) /* F may no longer exist if
3539 the frame was deleted. */
3541 /* While a frame is unmapped, display generation is
3542 disabled; you don't want to spend time updating a
3543 display that won't ever be seen. */
3544 f
->async_visible
= 0;
3545 /* We can't distinguish, from the event, whether the window
3546 has become iconified or invisible. So assume, if it
3547 was previously visible, than now it is iconified.
3548 We depend on x_make_frame_invisible to mark it iconified. */
3549 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
3550 f
->async_iconified
= 1;
3552 bufp
->kind
= iconify_event
;
3553 XSETFRAME (bufp
->frame_or_window
, f
);
3561 /* We use x_top_window_to_frame because map events can come
3562 for subwindows and they don't mean that the frame is visible. */
3563 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
3566 f
->async_visible
= 1;
3567 f
->async_iconified
= 0;
3569 /* wait_reading_process_input will notice this and update
3570 the frame's display structures. */
3571 SET_FRAME_GARBAGED (f
);
3575 bufp
->kind
= deiconify_event
;
3576 XSETFRAME (bufp
->frame_or_window
, f
);
3581 else if (! NILP(Vframe_list
)
3582 && ! NILP (XCONS (Vframe_list
)->cdr
))
3583 /* Force a redisplay sooner or later
3584 to update the frame titles
3585 in case this is the second frame. */
3586 record_asynch_buffer_change ();
3590 /* Turn off processing if we become fully obscured. */
3591 case VisibilityNotify
:
3595 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
3599 KeySym keysym
, orig_keysym
;
3600 /* al%imercury@uunet.uu.net says that making this 81 instead of
3601 80 fixed a bug whereby meta chars made his Emacs hang. */
3602 unsigned char copy_buffer
[81];
3606 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
3607 extra_keyboard_modifiers
);
3608 modifiers
= event
.xkey
.state
;
3610 /* This will have to go some day... */
3612 /* make_lispy_event turns chars into control chars.
3613 Don't do it here because XLookupString is too eager. */
3614 event
.xkey
.state
&= ~ControlMask
;
3615 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
3616 | dpyinfo
->super_mod_mask
3617 | dpyinfo
->hyper_mod_mask
3618 | dpyinfo
->alt_mod_mask
);
3623 /* The necessity of the following line took me
3624 a full work-day to decipher from the docs!! */
3625 if (XFilterEvent (&event
, None
))
3627 nbytes
= XmbLookupString (FRAME_XIC (f
),
3628 &event
.xkey
, copy_buffer
,
3633 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
3634 80, &keysym
, &compose_status
);
3636 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
3637 80, &keysym
, &compose_status
);
3640 orig_keysym
= keysym
;
3644 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
3645 || keysym
== XK_Delete
3646 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
3647 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
3649 /* This recognizes the "extended function keys".
3650 It seems there's no cleaner way.
3651 Test IsModifierKey to avoid handling mode_switch
3653 || ((unsigned) (keysym
) >= XK_Select
3654 && (unsigned)(keysym
) < XK_KP_Space
)
3656 #ifdef XK_dead_circumflex
3657 || orig_keysym
== XK_dead_circumflex
3659 #ifdef XK_dead_grave
3660 || orig_keysym
== XK_dead_grave
3662 #ifdef XK_dead_tilde
3663 || orig_keysym
== XK_dead_tilde
3665 #ifdef XK_dead_diaeresis
3666 || orig_keysym
== XK_dead_diaeresis
3668 #ifdef XK_dead_macron
3669 || orig_keysym
== XK_dead_macron
3671 #ifdef XK_dead_degree
3672 || orig_keysym
== XK_dead_degree
3674 #ifdef XK_dead_acute
3675 || orig_keysym
== XK_dead_acute
3677 #ifdef XK_dead_cedilla
3678 || orig_keysym
== XK_dead_cedilla
3680 #ifdef XK_dead_breve
3681 || orig_keysym
== XK_dead_breve
3683 #ifdef XK_dead_ogonek
3684 || orig_keysym
== XK_dead_ogonek
3686 #ifdef XK_dead_caron
3687 || orig_keysym
== XK_dead_caron
3689 #ifdef XK_dead_doubleacute
3690 || orig_keysym
== XK_dead_doubleacute
3692 #ifdef XK_dead_abovedot
3693 || orig_keysym
== XK_dead_abovedot
3695 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
3696 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
3697 /* Any "vendor-specific" key is ok. */
3698 || (orig_keysym
& (1 << 28)))
3699 && ! (IsModifierKey (orig_keysym
)
3701 #ifdef XK_Mode_switch
3702 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
3705 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
3707 #endif /* not HAVE_X11R5 */
3710 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3712 temp_buffer
[temp_index
++] = keysym
;
3713 bufp
->kind
= non_ascii_keystroke
;
3714 bufp
->code
= keysym
;
3715 XSETFRAME (bufp
->frame_or_window
, f
);
3717 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3719 bufp
->timestamp
= event
.xkey
.time
;
3724 else if (numchars
> nbytes
)
3728 for (i
= 0; i
< nbytes
; i
++)
3730 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3732 temp_buffer
[temp_index
++] = copy_buffer
[i
];
3733 bufp
->kind
= ascii_keystroke
;
3734 bufp
->code
= copy_buffer
[i
];
3735 XSETFRAME (bufp
->frame_or_window
, f
);
3737 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3739 bufp
->timestamp
= event
.xkey
.time
;
3754 /* Here's a possible interpretation of the whole
3755 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If you get a
3756 FocusIn event, you have to get a FocusOut event before you
3757 relinquish the focus. If you haven't received a FocusIn event,
3758 then a mere LeaveNotify is enough to free you. */
3761 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
3763 if (event
.xcrossing
.focus
) /* Entered Window */
3765 /* Avoid nasty pop/raise loops. */
3766 if (f
&& (!(f
->auto_raise
)
3768 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
3770 x_new_focus_frame (dpyinfo
, f
);
3771 enter_timestamp
= event
.xcrossing
.time
;
3774 else if (f
== dpyinfo
->x_focus_frame
)
3775 x_new_focus_frame (dpyinfo
, 0);
3776 /* EnterNotify counts as mouse movement,
3777 so update things that depend on mouse position. */
3779 note_mouse_movement (f
, &event
.xmotion
);
3783 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
3784 if (event
.xfocus
.detail
!= NotifyPointer
)
3785 dpyinfo
->x_focus_event_frame
= f
;
3787 x_new_focus_frame (dpyinfo
, f
);
3790 if (f
&& FRAME_XIC (f
))
3791 XSetICFocus (FRAME_XIC (f
));
3797 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
3800 if (f
== dpyinfo
->mouse_face_mouse_frame
)
3801 /* If we move outside the frame,
3802 then we're certainly no longer on any text in the frame. */
3803 clear_mouse_face (dpyinfo
);
3805 if (event
.xcrossing
.focus
)
3806 x_mouse_leave (dpyinfo
);
3809 if (f
== dpyinfo
->x_focus_event_frame
)
3810 dpyinfo
->x_focus_event_frame
= 0;
3811 if (f
== dpyinfo
->x_focus_frame
)
3812 x_new_focus_frame (dpyinfo
, 0);
3818 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
3819 if (event
.xfocus
.detail
!= NotifyPointer
3820 && f
== dpyinfo
->x_focus_event_frame
)
3821 dpyinfo
->x_focus_event_frame
= 0;
3822 if (f
&& f
== dpyinfo
->x_focus_frame
)
3823 x_new_focus_frame (dpyinfo
, 0);
3826 if (f
&& FRAME_XIC (f
))
3827 XUnsetICFocus (FRAME_XIC (f
));
3834 if (dpyinfo
->grabbed
&& last_mouse_frame
3835 && FRAME_LIVE_P (last_mouse_frame
))
3836 f
= last_mouse_frame
;
3838 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
3840 note_mouse_movement (f
, &event
.xmotion
);
3843 struct scroll_bar
*bar
3844 = x_window_to_scroll_bar (event
.xmotion
.window
);
3847 x_scroll_bar_note_movement (bar
, &event
);
3849 /* If we move outside the frame,
3850 then we're certainly no longer on any text in the frame. */
3851 clear_mouse_face (dpyinfo
);
3856 case ConfigureNotify
:
3857 f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
3859 #ifdef USE_X_TOOLKIT
3860 && (event
.xconfigure
.window
== XtWindow (f
->output_data
.x
->widget
))
3864 #ifndef USE_X_TOOLKIT
3865 /* In the toolkit version, change_frame_size
3866 is called by the code that handles resizing
3867 of the EmacsFrame widget. */
3869 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
3870 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
3872 /* Even if the number of character rows and columns has
3873 not changed, the font size may have changed, so we need
3874 to check the pixel dimensions as well. */
3875 if (columns
!= f
->width
3876 || rows
!= f
->height
3877 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
3878 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
3880 change_frame_size (f
, rows
, columns
, 0, 1);
3881 SET_FRAME_GARBAGED (f
);
3885 /* Formerly, in the USE_X_TOOLKIT version,
3886 we did not test send_event here. */
3888 #ifndef USE_X_TOOLKIT
3889 && ! event
.xconfigure
.send_event
3896 /* Find the position of the outside upper-left corner of
3897 the window, in the root coordinate system. Don't
3898 refer to the parent window here; we may be processing
3899 this event after the window manager has changed our
3900 parent, but before we have reached the ReparentNotify. */
3901 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3903 /* From-window, to-window. */
3904 event
.xconfigure
.window
,
3905 FRAME_X_DISPLAY_INFO (f
)->root_window
,
3907 /* From-position, to-position. */
3908 -event
.xconfigure
.border_width
,
3909 -event
.xconfigure
.border_width
,
3914 event
.xconfigure
.x
= win_x
;
3915 event
.xconfigure
.y
= win_y
;
3918 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
3919 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
3920 f
->output_data
.x
->left_pos
= event
.xconfigure
.x
;
3921 f
->output_data
.x
->top_pos
= event
.xconfigure
.y
;
3923 /* What we have now is the position of Emacs's own window.
3924 Convert that to the position of the window manager window. */
3927 x_real_positions (f
, &x
, &y
);
3928 f
->output_data
.x
->left_pos
= x
;
3929 f
->output_data
.x
->top_pos
= y
;
3930 /* Formerly we did not do this in the USE_X_TOOLKIT
3931 version. Let's try making them the same. */
3932 /* #ifndef USE_X_TOOLKIT */
3933 if (y
!= event
.xconfigure
.y
)
3935 /* Since the WM decorations come below top_pos now,
3936 we must put them below top_pos in the future. */
3937 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
3938 x_wm_set_size_hint (f
, (long) 0, 0);
3948 /* If we decide we want to generate an event to be seen
3949 by the rest of Emacs, we put it here. */
3950 struct input_event emacs_event
;
3951 emacs_event
.kind
= no_event
;
3953 bzero (&compose_status
, sizeof (compose_status
));
3955 if (dpyinfo
->grabbed
&& last_mouse_frame
3956 && FRAME_LIVE_P (last_mouse_frame
))
3957 f
= last_mouse_frame
;
3959 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
3963 if (!dpyinfo
->x_focus_frame
|| f
== dpyinfo
->x_focus_frame
)
3964 construct_mouse_click (&emacs_event
, &event
, f
);
3968 struct scroll_bar
*bar
3969 = x_window_to_scroll_bar (event
.xbutton
.window
);
3972 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
3975 if (event
.type
== ButtonPress
)
3977 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
3978 last_mouse_frame
= f
;
3982 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
3985 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
3987 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
3993 #ifdef USE_X_TOOLKIT
3994 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
3995 /* For a down-event in the menu bar,
3996 don't pass it to Xt right now.
3997 Instead, save it away
3998 and we will pass it to Xt from kbd_buffer_get_event.
3999 That way, we can run some Lisp code first. */
4000 if (f
&& event
.type
== ButtonPress
4001 /* Verify the event is really within the menu bar
4002 and not just sent to it due to grabbing. */
4003 && event
.xbutton
.x
>= 0
4004 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
4005 && event
.xbutton
.y
>= 0
4006 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
4007 && event
.xbutton
.same_screen
)
4009 if (f
->output_data
.x
->saved_button_event
== 0)
4010 f
->output_data
.x
->saved_button_event
4011 = (XButtonEvent
*) xmalloc (sizeof (XButtonEvent
));
4012 bcopy (&event
, f
->output_data
.x
->saved_button_event
,
4013 sizeof (XButtonEvent
));
4016 bufp
->kind
= menu_bar_activate_event
;
4017 XSETFRAME (bufp
->frame_or_window
, f
);
4025 #endif /* USE_X_TOOLKIT */
4029 case CirculateNotify
:
4031 case CirculateRequest
:
4035 /* Someone has changed the keyboard mapping - update the
4037 switch (event
.xmapping
.request
)
4039 case MappingModifier
:
4040 x_find_modifier_meanings (dpyinfo
);
4041 /* This is meant to fall through. */
4042 case MappingKeyboard
:
4043 XRefreshKeyboardMapping (&event
.xmapping
);
4049 #ifdef USE_X_TOOLKIT
4051 XtDispatchEvent (&event
);
4053 #endif /* USE_X_TOOLKIT */
4059 /* On some systems, an X bug causes Emacs to get no more events
4060 when the window is destroyed. Detect that. (1994.) */
4063 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
4064 One XNOOP in 100 loops will make Emacs terminate.
4065 B. Bretthauer, 1994 */
4067 if (x_noop_count
>= 100)
4071 if (next_noop_dpyinfo
== 0)
4072 next_noop_dpyinfo
= x_display_list
;
4074 XNoOp (next_noop_dpyinfo
->display
);
4076 /* Each time we get here, cycle through the displays now open. */
4077 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
4081 /* If the focus was just given to an autoraising frame,
4083 /* ??? This ought to be able to handle more than one such frame. */
4084 if (pending_autoraise_frame
)
4086 x_raise_frame (pending_autoraise_frame
);
4087 pending_autoraise_frame
= 0;
4094 /* Drawing the cursor. */
4097 /* Draw a hollow box cursor on frame F at X, Y.
4098 Don't change the inside of the box. */
4101 x_draw_box (f
, x
, y
)
4105 int left
= CHAR_TO_PIXEL_COL (f
, x
);
4106 int top
= CHAR_TO_PIXEL_ROW (f
, y
);
4107 int width
= FONT_WIDTH (f
->output_data
.x
->font
);
4108 int height
= f
->output_data
.x
->line_height
;
4110 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4111 f
->output_data
.x
->cursor_gc
,
4112 left
, top
, width
- 1, height
- 1);
4115 /* Clear the cursor of frame F to background color,
4116 and mark the cursor as not shown.
4117 This is used when the text where the cursor is
4118 is about to be rewritten. */
4126 if (! FRAME_VISIBLE_P (f
)
4127 || f
->phys_cursor_x
< 0)
4130 x_display_cursor (f
, 0);
4131 f
->phys_cursor_x
= -1;
4134 /* Redraw the glyph at ROW, COLUMN on frame F, in the style
4135 HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
4139 x_draw_single_glyph (f
, row
, column
, glyph
, highlight
)
4146 CHAR_TO_PIXEL_COL (f
, column
),
4147 CHAR_TO_PIXEL_ROW (f
, row
),
4148 &glyph
, 1, highlight
, 0);
4152 x_display_bar_cursor (f
, on
, x
, y
)
4157 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4159 /* This is pointless on invisible frames, and dangerous on garbaged
4160 frames; in the latter case, the frame may be in the midst of
4161 changing its size, and x and y may be off the frame. */
4162 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4165 if (! on
&& f
->phys_cursor_x
< 0)
4168 /* If there is anything wrong with the current cursor state, remove it. */
4169 if (f
->phys_cursor_x
>= 0
4171 || f
->phys_cursor_x
!= x
4172 || f
->phys_cursor_y
!= y
4173 || f
->output_data
.x
->current_cursor
!= bar_cursor
))
4175 /* Erase the cursor by redrawing the character underneath it. */
4176 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4177 f
->phys_cursor_glyph
,
4178 current_glyphs
->highlight
[f
->phys_cursor_y
]);
4179 f
->phys_cursor_x
= -1;
4182 /* If we now need a cursor in the new place or in the new form, do it so. */
4184 && (f
->phys_cursor_x
< 0
4185 || (f
->output_data
.x
->current_cursor
!= bar_cursor
)))
4187 f
->phys_cursor_glyph
4188 = ((current_glyphs
->enable
[y
]
4189 && x
< current_glyphs
->used
[y
])
4190 ? current_glyphs
->glyphs
[y
][x
]
4192 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4193 f
->output_data
.x
->cursor_gc
,
4194 CHAR_TO_PIXEL_COL (f
, x
),
4195 CHAR_TO_PIXEL_ROW (f
, y
),
4196 max (f
->output_data
.x
->cursor_width
, 1),
4197 f
->output_data
.x
->line_height
);
4199 f
->phys_cursor_x
= x
;
4200 f
->phys_cursor_y
= y
;
4202 f
->output_data
.x
->current_cursor
= bar_cursor
;
4205 if (updating_frame
!= f
)
4206 XFlush (FRAME_X_DISPLAY (f
));
4210 /* Turn the displayed cursor of frame F on or off according to ON.
4211 If ON is nonzero, where to put the cursor is specified by X and Y. */
4214 x_display_box_cursor (f
, on
, x
, y
)
4219 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4221 /* This is pointless on invisible frames, and dangerous on garbaged
4222 frames; in the latter case, the frame may be in the midst of
4223 changing its size, and x and y may be off the frame. */
4224 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4227 /* If cursor is off and we want it off, return quickly. */
4228 if (!on
&& f
->phys_cursor_x
< 0)
4231 /* If cursor is currently being shown and we don't want it to be
4232 or it is in the wrong place,
4233 or we want a hollow box and it's not so, (pout!)
4235 if (f
->phys_cursor_x
>= 0
4237 || f
->phys_cursor_x
!= x
4238 || f
->phys_cursor_y
!= y
4239 || (f
->output_data
.x
->current_cursor
!= hollow_box_cursor
4240 && (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
))))
4242 int mouse_face_here
= 0;
4243 struct frame_glyphs
*active_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4245 /* If the cursor is in the mouse face area, redisplay that when
4246 we clear the cursor. */
4247 if (f
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_mouse_frame
4249 (f
->phys_cursor_y
> FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
4250 || (f
->phys_cursor_y
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_row
4251 && f
->phys_cursor_x
>= FRAME_X_DISPLAY_INFO (f
)->mouse_face_beg_col
))
4253 (f
->phys_cursor_y
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
4254 || (f
->phys_cursor_y
== FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_row
4255 && f
->phys_cursor_x
< FRAME_X_DISPLAY_INFO (f
)->mouse_face_end_col
))
4256 /* Don't redraw the cursor's spot in mouse face
4257 if it is at the end of a line (on a newline).
4258 The cursor appears there, but mouse highlighting does not. */
4259 && active_glyphs
->used
[f
->phys_cursor_y
] > f
->phys_cursor_x
)
4260 mouse_face_here
= 1;
4262 /* If the font is not as tall as a whole line,
4263 we must explicitly clear the line's whole height. */
4264 if (FONT_HEIGHT (f
->output_data
.x
->font
) != f
->output_data
.x
->line_height
)
4265 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4266 CHAR_TO_PIXEL_COL (f
, f
->phys_cursor_x
),
4267 CHAR_TO_PIXEL_ROW (f
, f
->phys_cursor_y
),
4268 FONT_WIDTH (f
->output_data
.x
->font
),
4269 f
->output_data
.x
->line_height
, False
);
4270 /* Erase the cursor by redrawing the character underneath it. */
4271 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4272 f
->phys_cursor_glyph
,
4275 : current_glyphs
->highlight
[f
->phys_cursor_y
]));
4276 f
->phys_cursor_x
= -1;
4279 /* If we want to show a cursor,
4280 or we want a box cursor and it's not so,
4281 write it in the right place. */
4283 && (f
->phys_cursor_x
< 0
4284 || (f
->output_data
.x
->current_cursor
!= filled_box_cursor
4285 && f
== FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)))
4287 f
->phys_cursor_glyph
4288 = ((current_glyphs
->enable
[y
]
4289 && x
< current_glyphs
->used
[y
])
4290 ? current_glyphs
->glyphs
[y
][x
]
4292 if (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
4294 x_draw_box (f
, x
, y
);
4295 f
->output_data
.x
->current_cursor
= hollow_box_cursor
;
4299 x_draw_single_glyph (f
, y
, x
,
4300 f
->phys_cursor_glyph
, 2);
4301 f
->output_data
.x
->current_cursor
= filled_box_cursor
;
4304 f
->phys_cursor_x
= x
;
4305 f
->phys_cursor_y
= y
;
4308 if (updating_frame
!= f
)
4309 XFlush (FRAME_X_DISPLAY (f
));
4312 /* Display the cursor on frame F, or clear it, according to ON.
4313 Use the position specified by curs_x and curs_y
4314 if we are doing an update of frame F now.
4315 Otherwise use the position in the FRAME_CURSOR_X and FRAME_CURSOR_Y fields
4318 x_display_cursor (f
, on
)
4324 /* If we're not updating, then don't change the physical cursor
4325 position. Just change (if appropriate) the style of display. */
4326 if (f
!= updating_frame
)
4328 curs_x
= FRAME_CURSOR_X (f
);
4329 curs_y
= FRAME_CURSOR_Y (f
);
4332 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4333 x_display_box_cursor (f
, on
, curs_x
, curs_y
);
4334 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4335 x_display_bar_cursor (f
, on
, curs_x
, curs_y
);
4337 /* Those are the only two we have implemented! */
4343 /* Display the cursor on frame F, or clear it, according to ON.
4344 Don't change the cursor's position. */
4346 x_update_cursor (f
, on
)
4350 /* If we don't have any previous cursor position to use,
4351 leave the cursor off. */
4352 if (f
->phys_cursor_x
< 0)
4357 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4358 x_display_box_cursor (f
, on
, f
->phys_cursor_x
, f
->phys_cursor_y
);
4359 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4360 x_display_bar_cursor (f
, on
, f
->phys_cursor_x
, f
->phys_cursor_y
);
4362 /* Those are the only two we have implemented! */
4370 /* Refresh bitmap kitchen sink icon for frame F
4371 when we get an expose event for it. */
4376 /* Normally, the window manager handles this function. */
4379 /* Make the x-window of frame F use the gnu icon bitmap. */
4382 x_bitmap_icon (f
, file
)
4386 int mask
, bitmap_id
;
4389 if (FRAME_X_WINDOW (f
) == 0)
4392 /* Free up our existing icon bitmap if any. */
4393 if (f
->output_data
.x
->icon_bitmap
> 0)
4394 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
4395 f
->output_data
.x
->icon_bitmap
= 0;
4398 bitmap_id
= x_create_bitmap_from_file (f
, file
);
4401 /* Create the GNU bitmap if necessary. */
4402 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
4403 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
4404 = x_create_bitmap_from_data (f
, gnu_bits
,
4405 gnu_width
, gnu_height
);
4407 /* The first time we create the GNU bitmap,
4408 this increments the refcount one extra time.
4409 As a result, the GNU bitmap is never freed.
4410 That way, we don't have to worry about allocating it again. */
4411 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
4413 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
4416 x_wm_set_icon_pixmap (f
, bitmap_id
);
4417 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
4423 /* Make the x-window of frame F use a rectangle with text.
4424 Use ICON_NAME as the text. */
4427 x_text_icon (f
, icon_name
)
4431 if (FRAME_X_WINDOW (f
) == 0)
4437 text
.value
= (unsigned char *) icon_name
;
4438 text
.encoding
= XA_STRING
;
4440 text
.nitems
= strlen (icon_name
);
4441 #ifdef USE_X_TOOLKIT
4442 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
4444 #else /* not USE_X_TOOLKIT */
4445 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
4446 #endif /* not USE_X_TOOLKIT */
4448 #else /* not HAVE_X11R4 */
4449 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
4450 #endif /* not HAVE_X11R4 */
4452 if (f
->output_data
.x
->icon_bitmap
> 0)
4453 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
4454 f
->output_data
.x
->icon_bitmap
= 0;
4455 x_wm_set_icon_pixmap (f
, 0);
4460 /* Handling X errors. */
4462 /* Handle the loss of connection to display DISPLAY. */
4465 x_connection_closed (display
, error_message
)
4467 char *error_message
;
4469 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
4470 Lisp_Object frame
, tail
;
4472 /* Indicate that this display is dead. */
4474 dpyinfo
->display
= 0;
4476 /* First delete frames whose minibuffers are on frames
4477 that are on the dead display. */
4478 FOR_EACH_FRAME (tail
, frame
)
4480 Lisp_Object minibuf_frame
;
4482 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
4483 if (FRAME_X_P (XFRAME (frame
))
4484 && FRAME_X_P (XFRAME (minibuf_frame
))
4485 && ! EQ (frame
, minibuf_frame
)
4486 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
4487 Fdelete_frame (frame
, Qt
);
4490 /* Now delete all remaining frames on the dead display.
4491 We are now sure none of these is used as the minibuffer
4492 for another frame that we need to delete. */
4493 FOR_EACH_FRAME (tail
, frame
)
4494 if (FRAME_X_P (XFRAME (frame
))
4495 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
4497 /* Set this to t so that Fdelete_frame won't get confused
4498 trying to find a replacement. */
4499 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
4500 Fdelete_frame (frame
, Qt
);
4504 x_delete_display (dpyinfo
);
4506 if (x_display_list
== 0)
4508 fprintf (stderr
, "%s", error_message
);
4509 shut_down_emacs (0, 0, Qnil
);
4513 /* Ordinary stack unwind doesn't deal with these. */
4515 sigunblock (sigmask (SIGIO
));
4517 sigunblock (sigmask (SIGALRM
));
4518 TOTALLY_UNBLOCK_INPUT
;
4520 error ("%s", error_message
);
4523 /* This is the usual handler for X protocol errors.
4524 It kills all frames on the display that we got the error for.
4525 If that was the only one, it prints an error message and kills Emacs. */
4528 x_error_quitter (display
, error
)
4532 char buf
[256], buf1
[356];
4534 /* Note that there is no real way portable across R3/R4 to get the
4535 original error handler. */
4537 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
4538 sprintf (buf1
, "X protocol error: %s on protocol request %d\n",
4539 buf
, error
->request_code
);
4540 x_connection_closed (display
, buf1
);
4543 /* This is the handler for X IO errors, always.
4544 It kills all frames on the display that we lost touch with.
4545 If that was the only one, it prints an error message and kills Emacs. */
4548 x_io_error_quitter (display
)
4553 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
4554 x_connection_closed (display
, buf
);
4557 /* Handle SIGPIPE, which can happen when the connection to a server
4558 simply goes away. SIGPIPE is handled by x_connection_signal.
4559 It works by sending a no-op command to each X server connection.
4560 When we try a connection that has closed, we get SIGPIPE again.
4561 But this time, it is handled by x_connection_signal_1.
4562 That function knows which connection we were testing,
4563 so it closes that one.
4565 x_connection_closed never returns,
4566 so if more than one connection was lost at once,
4567 we only find one. But XTread_socket keeps trying them all,
4568 so it will notice the other closed one sooner or later. */
4571 static struct x_display_info
*x_connection_signal_dpyinfo
;
4573 static SIGTYPE
x_connection_signal ();
4576 x_connection_signal_1 (signalnum
) /* If we don't have an argument, */
4577 int signalnum
; /* some compilers complain in signal calls. */
4579 signal (SIGPIPE
, x_connection_signal
);
4580 x_connection_closed (x_connection_signal_dpyinfo
,
4581 "connection was lost");
4585 x_connection_signal (signalnum
) /* If we don't have an argument, */
4586 int signalnum
; /* some compilers complain in signal calls. */
4588 x_connection_signal_dpyinfo
= x_display_list
;
4590 sigunblock (sigmask (SIGPIPE
));
4592 while (x_connection_signal_dpyinfo
)
4594 signal (SIGPIPE
, x_connection_signal_1
);
4596 x_connection_close_if_hung (x_connection_signal_dpyinfo
);
4598 XNoOp (x_connection_signal_dpyinfo
->display
);
4600 XSync (x_connection_signal_dpyinfo
->display
, False
);
4602 /* Each time we get here, cycle through the displays now open. */
4603 x_connection_signal_dpyinfo
= x_connection_signal_dpyinfo
->next
;
4606 /* We should have found some closed connection. */
4610 /* A buffer for storing X error messages. */
4611 static char *x_caught_error_message
;
4612 #define X_CAUGHT_ERROR_MESSAGE_SIZE 200
4614 /* An X error handler which stores the error message in
4615 x_caught_error_message. This is what's installed when
4616 x_catch_errors is in effect. */
4619 x_error_catcher (display
, error
)
4623 XGetErrorText (display
, error
->error_code
,
4624 x_caught_error_message
, X_CAUGHT_ERROR_MESSAGE_SIZE
);
4628 /* Begin trapping X errors for display DPY. Actually we trap X errors
4629 for all displays, but DPY should be the display you are actually
4632 After calling this function, X protocol errors no longer cause
4633 Emacs to exit; instead, they are recorded in x_cfc_error_message.
4635 Calling x_check_errors signals an Emacs error if an X error has
4636 occurred since the last call to x_catch_errors or x_check_errors.
4638 Calling x_uncatch_errors resumes the normal error handling. */
4640 void x_catch_errors (), x_check_errors (), x_uncatch_errors ();
4643 x_catch_errors (dpy
)
4646 /* Make sure any errors from previous requests have been dealt with. */
4649 /* Set up the error buffer. */
4650 x_caught_error_message
4651 = (char*) xmalloc (X_CAUGHT_ERROR_MESSAGE_SIZE
);
4652 x_caught_error_message
[0] = '\0';
4654 /* Install our little error handler. */
4655 XSetErrorHandler (x_error_catcher
);
4658 /* If any X protocol errors have arrived since the last call to
4659 x_catch_errors or x_check_errors, signal an Emacs error using
4660 sprintf (a buffer, FORMAT, the x error message text) as the text. */
4663 x_check_errors (dpy
, format
)
4667 /* Make sure to catch any errors incurred so far. */
4670 if (x_caught_error_message
[0])
4672 char buf
[X_CAUGHT_ERROR_MESSAGE_SIZE
+ 56];
4674 sprintf (buf
, format
, x_caught_error_message
);
4675 x_uncatch_errors (dpy
);
4680 /* Nonzero if we had any X protocol errors since we did x_catch_errors. */
4683 x_had_errors_p (dpy
)
4686 /* Make sure to catch any errors incurred so far. */
4689 return x_caught_error_message
[0] != 0;
4692 /* Stop catching X protocol errors and let them make Emacs die. */
4695 x_uncatch_errors (dpy
)
4698 xfree (x_caught_error_message
);
4699 x_caught_error_message
= 0;
4700 XSetErrorHandler (x_error_quitter
);
4704 static unsigned int x_wire_count
;
4707 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
4712 /* Changing the font of the frame. */
4714 /* Give frame F the font named FONTNAME as its default font, and
4715 return the full name of that font. FONTNAME may be a wildcard
4716 pattern; in that case, we choose some font that fits the pattern.
4717 The return value shows which font we chose. */
4720 x_new_font (f
, fontname
)
4722 register char *fontname
;
4725 int n_matching_fonts
;
4726 XFontStruct
*font_info
;
4729 /* Get a list of all the fonts that match this name. Once we
4730 have a list of matching fonts, we compare them against the fonts
4731 we already have by comparing font ids. */
4732 font_names
= (char **) XListFonts (FRAME_X_DISPLAY (f
), fontname
,
4733 1024, &n_matching_fonts
);
4734 /* Apparently it doesn't set n_matching_fonts to zero when it can't
4735 find any matches; font_names == 0 is the only clue. */
4737 n_matching_fonts
= 0;
4739 /* Don't just give up if n_matching_fonts is 0.
4740 Apparently there's a bug on Suns: XListFontsWithInfo can
4741 fail to find a font, but XLoadQueryFont may still find it. */
4743 /* See if we've already loaded a matching font. */
4744 already_loaded
= -1;
4745 if (n_matching_fonts
!= 0)
4749 for (i
= 0; i
< FRAME_X_DISPLAY_INFO (f
)->n_fonts
; i
++)
4750 for (j
= 0; j
< n_matching_fonts
; j
++)
4751 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].name
, font_names
[j
])
4752 || !strcmp (FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].full_name
, font_names
[j
]))
4755 fontname
= FRAME_X_DISPLAY_INFO (f
)->font_table
[i
].full_name
;
4761 /* If we have, just return it from the table. */
4762 if (already_loaded
>= 0)
4763 f
->output_data
.x
->font
= FRAME_X_DISPLAY_INFO (f
)->font_table
[already_loaded
].font
;
4764 /* Otherwise, load the font and add it to the table. */
4773 /* Try to find a character-cell font in the list. */
4775 /* A laudable goal, but this isn't how to do it. */
4776 for (i
= 0; i
< n_matching_fonts
; i
++)
4777 if (! font_info
[i
].per_char
)
4783 /* See comment above. */
4784 if (n_matching_fonts
!= 0)
4785 fontname
= font_names
[i
];
4787 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
4790 /* Free the information from XListFonts. */
4791 if (n_matching_fonts
)
4792 XFreeFontNames (font_names
);
4796 /* Do we need to create the table? */
4797 if (FRAME_X_DISPLAY_INFO (f
)->font_table_size
== 0)
4799 FRAME_X_DISPLAY_INFO (f
)->font_table_size
= 16;
4800 FRAME_X_DISPLAY_INFO (f
)->font_table
4801 = (struct font_info
*) xmalloc (FRAME_X_DISPLAY_INFO (f
)->font_table_size
4802 * sizeof (struct font_info
));
4804 /* Do we need to grow the table? */
4805 else if (FRAME_X_DISPLAY_INFO (f
)->n_fonts
4806 >= FRAME_X_DISPLAY_INFO (f
)->font_table_size
)
4808 FRAME_X_DISPLAY_INFO (f
)->font_table_size
*= 2;
4809 FRAME_X_DISPLAY_INFO (f
)->font_table
4810 = (struct font_info
*) xrealloc (FRAME_X_DISPLAY_INFO (f
)->font_table
,
4811 (FRAME_X_DISPLAY_INFO (f
)->font_table_size
4812 * sizeof (struct font_info
)));
4815 /* Try to get the full name of FONT. Put it in full_name. */
4817 FONT_atom
= XInternAtom (FRAME_X_DISPLAY (f
), "FONT", False
);
4818 for (i
= 0; i
< font
->n_properties
; i
++)
4820 if (FONT_atom
== font
->properties
[i
].name
)
4822 char *name
= XGetAtomName (FRAME_X_DISPLAY (f
),
4823 (Atom
) (font
->properties
[i
].card32
));
4827 /* Count the number of dashes in the "full name".
4828 If it is too few, this isn't really the font's full name,
4830 In X11R4, the fonts did not come with their canonical names
4846 n_fonts
= FRAME_X_DISPLAY_INFO (f
)->n_fonts
;
4847 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
= (char *) xmalloc (strlen (fontname
) + 1);
4848 bcopy (fontname
, FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
, strlen (fontname
) + 1);
4850 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].full_name
= full_name
;
4852 FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].full_name
= FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
;
4853 f
->output_data
.x
->font
= FRAME_X_DISPLAY_INFO (f
)->font_table
[n_fonts
].font
= font
;
4854 FRAME_X_DISPLAY_INFO (f
)->n_fonts
++;
4857 fontname
= full_name
;
4860 /* Compute the scroll bar width in character columns. */
4861 if (f
->scroll_bar_pixel_width
> 0)
4863 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
4864 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
4867 f
->scroll_bar_cols
= 2;
4869 /* Now make the frame display the given font. */
4870 if (FRAME_X_WINDOW (f
) != 0)
4872 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
4873 f
->output_data
.x
->font
->fid
);
4874 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
4875 f
->output_data
.x
->font
->fid
);
4876 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
4877 f
->output_data
.x
->font
->fid
);
4879 frame_update_line_height (f
);
4880 x_set_window_size (f
, 0, f
->width
, f
->height
);
4883 /* If we are setting a new frame's font for the first time,
4884 there are no faces yet, so this font's height is the line height. */
4885 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
4888 Lisp_Object lispy_name
;
4890 lispy_name
= build_string (fontname
);
4892 /* Free the information from XListFonts. The data
4893 we actually retain comes from XLoadQueryFont. */
4894 XFreeFontNames (font_names
);
4900 /* Calculate the absolute position in frame F
4901 from its current recorded position values and gravity. */
4903 x_calc_absolute_position (f
)
4907 int win_x
= 0, win_y
= 0;
4908 int flags
= f
->output_data
.x
->size_hint_flags
;
4911 #ifdef USE_X_TOOLKIT
4912 this_window
= XtWindow (f
->output_data
.x
->widget
);
4914 this_window
= FRAME_X_WINDOW (f
);
4917 /* Find the position of the outside upper-left corner of
4918 the inner window, with respect to the outer window. */
4919 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
4922 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
4924 /* From-window, to-window. */
4926 f
->output_data
.x
->parent_desc
,
4928 /* From-position, to-position. */
4929 0, 0, &win_x
, &win_y
,
4936 /* Treat negative positions as relative to the leftmost bottommost
4937 position that fits on the screen. */
4938 if (flags
& XNegative
)
4939 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
4940 - 2 * f
->output_data
.x
->border_width
- win_x
4942 + f
->output_data
.x
->left_pos
);
4944 if (flags
& YNegative
)
4945 /* We used to subtract f->output_data.x->menubar_height here
4946 in the toolkit case, but PIXEL_HEIGHT already includes that. */
4947 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
4948 - 2 * f
->output_data
.x
->border_width
- win_y
4950 + f
->output_data
.x
->top_pos
);
4952 /* The left_pos and top_pos
4953 are now relative to the top and left screen edges,
4954 so the flags should correspond. */
4955 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
4958 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
4959 to really change the position, and 0 when calling from
4960 x_make_frame_visible (in that case, XOFF and YOFF are the current
4961 position values). It is -1 when calling from x_set_frame_parameters,
4962 which means, do adjust for borders but don't change the gravity. */
4964 x_set_offset (f
, xoff
, yoff
, change_gravity
)
4966 register int xoff
, yoff
;
4969 int modified_top
, modified_left
;
4971 if (change_gravity
> 0)
4973 f
->output_data
.x
->top_pos
= yoff
;
4974 f
->output_data
.x
->left_pos
= xoff
;
4975 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
4977 f
->output_data
.x
->size_hint_flags
|= XNegative
;
4979 f
->output_data
.x
->size_hint_flags
|= YNegative
;
4980 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
4982 x_calc_absolute_position (f
);
4985 x_wm_set_size_hint (f
, (long) 0, 0);
4987 /* It is a mystery why we need to add the border_width here
4988 when the frame is already visible, but experiment says we do. */
4989 modified_left
= f
->output_data
.x
->left_pos
;
4990 modified_top
= f
->output_data
.x
->top_pos
;
4991 if (change_gravity
!= 0)
4993 modified_left
+= f
->output_data
.x
->border_width
;
4994 modified_top
+= f
->output_data
.x
->border_width
;
4997 #ifdef USE_X_TOOLKIT
4998 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
4999 modified_left
, modified_top
);
5000 #else /* not USE_X_TOOLKIT */
5001 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5002 modified_left
, modified_top
);
5003 #endif /* not USE_X_TOOLKIT */
5007 /* Call this to change the size of frame F's x-window.
5008 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5009 for this size change and subsequent size changes.
5010 Otherwise we leave the window gravity unchanged. */
5012 x_set_window_size (f
, change_gravity
, cols
, rows
)
5017 int pixelwidth
, pixelheight
;
5020 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5024 #ifdef USE_X_TOOLKIT
5026 /* The x and y position of the widget is clobbered by the
5027 call to XtSetValues within EmacsFrameSetCharSize.
5028 This is a real kludge, but I don't understand Xt so I can't
5029 figure out a correct fix. Can anyone else tell me? -- rms. */
5030 int xpos
= f
->output_data
.x
->widget
->core
.x
;
5031 int ypos
= f
->output_data
.x
->widget
->core
.y
;
5032 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
5033 f
->output_data
.x
->widget
->core
.x
= xpos
;
5034 f
->output_data
.x
->widget
->core
.y
= ypos
;
5037 #else /* not USE_X_TOOLKIT */
5039 check_frame_size (f
, &rows
, &cols
);
5040 f
->output_data
.x
->vertical_scroll_bar_extra
5041 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5043 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
5044 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
5045 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
5046 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
5047 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
5049 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
5050 x_wm_set_size_hint (f
, (long) 0, 0);
5052 XSync (FRAME_X_DISPLAY (f
), False
);
5053 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5054 pixelwidth
, pixelheight
);
5056 /* Now, strictly speaking, we can't be sure that this is accurate,
5057 but the window manager will get around to dealing with the size
5058 change request eventually, and we'll hear how it went when the
5059 ConfigureNotify event gets here.
5061 We could just not bother storing any of this information here,
5062 and let the ConfigureNotify event set everything up, but that
5063 might be kind of confusing to the lisp code, since size changes
5064 wouldn't be reported in the frame parameters until some random
5065 point in the future when the ConfigureNotify event arrives. */
5066 change_frame_size (f
, rows
, cols
, 0, 0);
5067 PIXEL_WIDTH (f
) = pixelwidth
;
5068 PIXEL_HEIGHT (f
) = pixelheight
;
5070 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5071 receive in the ConfigureNotify event; if we get what we asked
5072 for, then the event won't cause the screen to become garbaged, so
5073 we have to make sure to do it here. */
5074 SET_FRAME_GARBAGED (f
);
5076 XFlush (FRAME_X_DISPLAY (f
));
5078 #endif /* not USE_X_TOOLKIT */
5080 /* If cursor was outside the new size, mark it as off. */
5081 if (f
->phys_cursor_y
>= rows
5082 || f
->phys_cursor_x
>= cols
)
5084 f
->phys_cursor_x
= -1;
5085 f
->phys_cursor_y
= -1;
5088 /* Clear out any recollection of where the mouse highlighting was,
5089 since it might be in a place that's outside the new frame size.
5090 Actually checking whether it is outside is a pain in the neck,
5091 so don't try--just let the highlighting be done afresh with new size. */
5092 window
= dpyinfo
->mouse_face_window
;
5093 if (! NILP (window
) && XFRAME (window
) == f
)
5095 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
5096 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
5097 dpyinfo
->mouse_face_window
= Qnil
;
5103 /* Mouse warping. */
5106 x_set_mouse_position (f
, x
, y
)
5112 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
5113 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
5115 if (pix_x
< 0) pix_x
= 0;
5116 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
5118 if (pix_y
< 0) pix_y
= 0;
5119 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
5123 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
5124 0, 0, 0, 0, pix_x
, pix_y
);
5128 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
5131 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
5137 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
5138 0, 0, 0, 0, pix_x
, pix_y
);
5142 /* focus shifting, raising and lowering. */
5144 x_focus_on_frame (f
)
5147 #if 0 /* This proves to be unpleasant. */
5151 /* I don't think that the ICCCM allows programs to do things like this
5152 without the interaction of the window manager. Whatever you end up
5153 doing with this code, do it to x_unfocus_frame too. */
5154 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5155 RevertToPointerRoot
, CurrentTime
);
5163 /* Look at the remarks in x_focus_on_frame. */
5164 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
5165 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
5166 RevertToPointerRoot
, CurrentTime
);
5170 /* Raise frame F. */
5175 if (f
->async_visible
)
5178 #ifdef USE_X_TOOLKIT
5179 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
5180 #else /* not USE_X_TOOLKIT */
5181 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5182 #endif /* not USE_X_TOOLKIT */
5183 XFlush (FRAME_X_DISPLAY (f
));
5188 /* Lower frame F. */
5193 if (f
->async_visible
)
5196 #ifdef USE_X_TOOLKIT
5197 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
5198 #else /* not USE_X_TOOLKIT */
5199 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5200 #endif /* not USE_X_TOOLKIT */
5201 XFlush (FRAME_X_DISPLAY (f
));
5207 XTframe_raise_lower (f
, raise_flag
)
5217 /* Change of visibility. */
5219 /* This tries to wait until the frame is really visible.
5220 However, if the window manager asks the user where to position
5221 the frame, this will return before the user finishes doing that.
5222 The frame will not actually be visible at that time,
5223 but it will become visible later when the window manager
5224 finishes with it. */
5226 x_make_frame_visible (f
)
5234 type
= x_icon_type (f
);
5236 x_bitmap_icon (f
, type
);
5238 if (! FRAME_VISIBLE_P (f
))
5240 /* We test FRAME_GARBAGED_P here to make sure we don't
5241 call x_set_offset a second time
5242 if we get to x_make_frame_visible a second time
5243 before the window gets really visible. */
5244 if (! FRAME_ICONIFIED_P (f
)
5245 && ! f
->output_data
.x
->asked_for_visible
)
5246 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
5248 f
->output_data
.x
->asked_for_visible
= 1;
5250 if (! EQ (Vx_no_window_manager
, Qt
))
5251 x_wm_set_window_state (f
, NormalState
);
5252 #ifdef USE_X_TOOLKIT
5253 /* This was XtPopup, but that did nothing for an iconified frame. */
5254 XtMapWidget (f
->output_data
.x
->widget
);
5255 #else /* not USE_X_TOOLKIT */
5256 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5257 #endif /* not USE_X_TOOLKIT */
5258 #if 0 /* This seems to bring back scroll bars in the wrong places
5259 if the window configuration has changed. They seem
5260 to come back ok without this. */
5261 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5262 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5266 XFlush (FRAME_X_DISPLAY (f
));
5268 /* Synchronize to ensure Emacs knows the frame is visible
5269 before we do anything else. We do this loop with input not blocked
5270 so that incoming events are handled. */
5273 int count
= input_signal_count
;
5275 /* This must come after we set COUNT. */
5278 XSETFRAME (frame
, f
);
5283 /* Once we have handled input events,
5284 we should have received the MapNotify if one is coming.
5285 So if we have not got it yet, stop looping.
5286 Some window managers make their own decisions
5287 about visibility. */
5288 if (input_signal_count
!= count
)
5290 /* Machines that do polling rather than SIGIO have been observed
5291 to go into a busy-wait here. So we'll fake an alarm signal
5292 to let the handler know that there's something to be read.
5293 We used to raise a real alarm, but it seems that the handler
5294 isn't always enabled here. This is probably a bug. */
5295 if (input_polling_used ())
5297 /* It could be confusing if a real alarm arrives while processing
5298 the fake one. Turn it off and let the handler reset it. */
5300 input_poll_signal ();
5302 /* Once we have handled input events,
5303 we should have received the MapNotify if one is coming.
5304 So if we have not got it yet, stop looping.
5305 Some window managers make their own decisions
5306 about visibility. */
5307 if (input_signal_count
!= count
)
5310 FRAME_SAMPLE_VISIBILITY (f
);
5314 /* Change from mapped state to withdrawn state. */
5316 /* Make the frame visible (mapped and not iconified). */
5318 x_make_frame_invisible (f
)
5324 #ifdef USE_X_TOOLKIT
5325 /* Use the frame's outermost window, not the one we normally draw on. */
5326 window
= XtWindow (f
->output_data
.x
->widget
);
5327 #else /* not USE_X_TOOLKIT */
5328 window
= FRAME_X_WINDOW (f
);
5329 #endif /* not USE_X_TOOLKIT */
5331 /* Don't keep the highlight on an invisible frame. */
5332 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5333 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5335 #if 0/* This might add unreliability; I don't trust it -- rms. */
5336 if (! f
->async_visible
&& ! f
->async_iconified
)
5342 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
5343 that the current position of the window is user-specified, rather than
5344 program-specified, so that when the window is mapped again, it will be
5345 placed at the same location, without forcing the user to position it
5346 by hand again (they have already done that once for this window.) */
5347 x_wm_set_size_hint (f
, (long) 0, 1);
5351 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
5352 DefaultScreen (FRAME_X_DISPLAY (f
))))
5354 UNBLOCK_INPUT_RESIGNAL
;
5355 error ("Can't notify window manager of window withdrawal");
5357 #else /* ! defined (HAVE_X11R4) */
5359 /* Tell the window manager what we're going to do. */
5360 if (! EQ (Vx_no_window_manager
, Qt
))
5364 unmap
.xunmap
.type
= UnmapNotify
;
5365 unmap
.xunmap
.window
= window
;
5366 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
5367 unmap
.xunmap
.from_configure
= False
;
5368 if (! XSendEvent (FRAME_X_DISPLAY (f
),
5369 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
5371 SubstructureRedirectMask
|SubstructureNotifyMask
,
5374 UNBLOCK_INPUT_RESIGNAL
;
5375 error ("Can't notify window manager of withdrawal");
5379 /* Unmap the window ourselves. Cheeky! */
5380 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
5381 #endif /* ! defined (HAVE_X11R4) */
5383 /* We can't distinguish this from iconification
5384 just by the event that we get from the server.
5385 So we can't win using the usual strategy of letting
5386 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5387 and synchronize with the server to make sure we agree. */
5389 FRAME_ICONIFIED_P (f
) = 0;
5390 f
->async_visible
= 0;
5391 f
->async_iconified
= 0;
5398 /* Change window state from mapped to iconified. */
5407 /* Don't keep the highlight on an invisible frame. */
5408 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5409 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5411 if (f
->async_iconified
)
5416 FRAME_SAMPLE_VISIBILITY (f
);
5418 type
= x_icon_type (f
);
5420 x_bitmap_icon (f
, type
);
5422 #ifdef USE_X_TOOLKIT
5424 if (! FRAME_VISIBLE_P (f
))
5426 if (! EQ (Vx_no_window_manager
, Qt
))
5427 x_wm_set_window_state (f
, IconicState
);
5428 /* This was XtPopup, but that did nothing for an iconified frame. */
5429 XtMapWidget (f
->output_data
.x
->widget
);
5434 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
5435 XtWindow (f
->output_data
.x
->widget
),
5436 DefaultScreen (FRAME_X_DISPLAY (f
)));
5440 error ("Can't notify window manager of iconification");
5442 f
->async_iconified
= 1;
5445 XFlush (FRAME_X_DISPLAY (f
));
5447 #else /* not USE_X_TOOLKIT */
5449 /* Make sure the X server knows where the window should be positioned,
5450 in case the user deiconifies with the window manager. */
5451 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
5452 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
5454 /* Since we don't know which revision of X we're running, we'll use both
5455 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
5457 /* X11R4: send a ClientMessage to the window manager using the
5458 WM_CHANGE_STATE type. */
5462 message
.xclient
.window
= FRAME_X_WINDOW (f
);
5463 message
.xclient
.type
= ClientMessage
;
5464 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
5465 message
.xclient
.format
= 32;
5466 message
.xclient
.data
.l
[0] = IconicState
;
5468 if (! XSendEvent (FRAME_X_DISPLAY (f
),
5469 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
5471 SubstructureRedirectMask
| SubstructureNotifyMask
,
5474 UNBLOCK_INPUT_RESIGNAL
;
5475 error ("Can't notify window manager of iconification");
5479 /* X11R3: set the initial_state field of the window manager hints to
5481 x_wm_set_window_state (f
, IconicState
);
5483 if (!FRAME_VISIBLE_P (f
))
5485 /* If the frame was withdrawn, before, we must map it. */
5486 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5489 f
->async_iconified
= 1;
5491 XFlush (FRAME_X_DISPLAY (f
));
5493 #endif /* not USE_X_TOOLKIT */
5496 /* Destroy the X window of frame F. */
5498 x_destroy_window (f
)
5501 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5505 /* If a display connection is dead, don't try sending more
5506 commands to the X server. */
5507 if (dpyinfo
->display
!= 0)
5509 if (f
->output_data
.x
->icon_desc
!= 0)
5510 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
5514 XDestroyIC (FRAME_XIC (f
));
5515 #if ! defined (SOLARIS2) || defined (HAVE_X11R6)
5516 /* This line causes crashes on Solaris with Openwin,
5517 due to an apparent bug in XCloseIM.
5518 X11R6 seems not to have the bug. */
5519 XCloseIM (FRAME_XIM (f
));
5523 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->window_desc
);
5524 #ifdef USE_X_TOOLKIT
5525 XtDestroyWidget (f
->output_data
.x
->widget
);
5526 free_frame_menubar (f
);
5527 #endif /* USE_X_TOOLKIT */
5529 free_frame_faces (f
);
5530 XFlush (FRAME_X_DISPLAY (f
));
5533 xfree (f
->output_data
.x
);
5534 f
->output_data
.x
= 0;
5535 if (f
== dpyinfo
->x_focus_frame
)
5536 dpyinfo
->x_focus_frame
= 0;
5537 if (f
== dpyinfo
->x_focus_event_frame
)
5538 dpyinfo
->x_focus_event_frame
= 0;
5539 if (f
== dpyinfo
->x_highlight_frame
)
5540 dpyinfo
->x_highlight_frame
= 0;
5542 dpyinfo
->reference_count
--;
5544 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5546 dpyinfo
->mouse_face_beg_row
5547 = dpyinfo
->mouse_face_beg_col
= -1;
5548 dpyinfo
->mouse_face_end_row
5549 = dpyinfo
->mouse_face_end_col
= -1;
5550 dpyinfo
->mouse_face_window
= Qnil
;
5556 /* Setting window manager hints. */
5558 /* Set the normal size hints for the window manager, for frame F.
5559 FLAGS is the flags word to use--or 0 meaning preserve the flags
5560 that the window now has.
5561 If USER_POSITION is nonzero, we set the USPosition
5562 flag (this is useful when FLAGS is 0). */
5564 x_wm_set_size_hint (f
, flags
, user_position
)
5569 XSizeHints size_hints
;
5571 #ifdef USE_X_TOOLKIT
5574 Dimension widget_width
, widget_height
;
5575 Window window
= XtWindow (f
->output_data
.x
->widget
);
5576 #else /* not USE_X_TOOLKIT */
5577 Window window
= FRAME_X_WINDOW (f
);
5578 #endif /* not USE_X_TOOLKIT */
5580 /* Setting PMaxSize caused various problems. */
5581 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
5583 flexlines
= f
->height
;
5585 size_hints
.x
= f
->output_data
.x
->left_pos
;
5586 size_hints
.y
= f
->output_data
.x
->top_pos
;
5588 #ifdef USE_X_TOOLKIT
5589 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
5590 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
5591 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
5592 size_hints
.height
= widget_height
;
5593 size_hints
.width
= widget_width
;
5594 #else /* not USE_X_TOOLKIT */
5595 size_hints
.height
= PIXEL_HEIGHT (f
);
5596 size_hints
.width
= PIXEL_WIDTH (f
);
5597 #endif /* not USE_X_TOOLKIT */
5599 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
5600 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
5601 size_hints
.max_width
5602 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
5603 size_hints
.max_height
5604 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
5606 /* Calculate the base and minimum sizes.
5608 (When we use the X toolkit, we don't do it here.
5609 Instead we copy the values that the widgets are using, below.) */
5610 #ifndef USE_X_TOOLKIT
5612 int base_width
, base_height
;
5613 int min_rows
= 0, min_cols
= 0;
5615 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
5616 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
5618 check_frame_size (f
, &min_rows
, &min_cols
);
5620 /* The window manager uses the base width hints to calculate the
5621 current number of rows and columns in the frame while
5622 resizing; min_width and min_height aren't useful for this
5623 purpose, since they might not give the dimensions for a
5624 zero-row, zero-column frame.
5626 We use the base_width and base_height members if we have
5627 them; otherwise, we set the min_width and min_height members
5628 to the size for a zero x zero frame. */
5631 size_hints
.flags
|= PBaseSize
;
5632 size_hints
.base_width
= base_width
;
5633 size_hints
.base_height
= base_height
;
5634 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
5635 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
5637 size_hints
.min_width
= base_width
;
5638 size_hints
.min_height
= base_height
;
5642 /* If we don't need the old flags, we don't need the old hint at all. */
5645 size_hints
.flags
|= flags
;
5648 #endif /* not USE_X_TOOLKIT */
5651 XSizeHints hints
; /* Sometimes I hate X Windows... */
5652 long supplied_return
;
5656 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
5659 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
5662 #ifdef USE_X_TOOLKIT
5663 size_hints
.base_height
= hints
.base_height
;
5664 size_hints
.base_width
= hints
.base_width
;
5665 size_hints
.min_height
= hints
.min_height
;
5666 size_hints
.min_width
= hints
.min_width
;
5670 size_hints
.flags
|= flags
;
5675 if (hints
.flags
& PSize
)
5676 size_hints
.flags
|= PSize
;
5677 if (hints
.flags
& PPosition
)
5678 size_hints
.flags
|= PPosition
;
5679 if (hints
.flags
& USPosition
)
5680 size_hints
.flags
|= USPosition
;
5681 if (hints
.flags
& USSize
)
5682 size_hints
.flags
|= USSize
;
5689 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
5690 size_hints
.flags
|= PWinGravity
;
5694 size_hints
.flags
&= ~ PPosition
;
5695 size_hints
.flags
|= USPosition
;
5697 #endif /* PWinGravity */
5700 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
5702 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
5706 /* Used for IconicState or NormalState */
5707 x_wm_set_window_state (f
, state
)
5711 #ifdef USE_X_TOOLKIT
5714 XtSetArg (al
[0], XtNinitialState
, state
);
5715 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
5716 #else /* not USE_X_TOOLKIT */
5717 Window window
= FRAME_X_WINDOW (f
);
5719 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
5720 f
->output_data
.x
->wm_hints
.initial_state
= state
;
5722 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5723 #endif /* not USE_X_TOOLKIT */
5726 x_wm_set_icon_pixmap (f
, pixmap_id
)
5730 #ifdef USE_X_TOOLKIT
5731 Window window
= XtWindow (f
->output_data
.x
->widget
);
5733 Window window
= FRAME_X_WINDOW (f
);
5738 Pixmap icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
5739 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
5743 /* It seems there is no way to turn off use of an icon pixmap.
5744 The following line does it, only if no icon has yet been created,
5745 for some window managers. But with mwm it crashes.
5746 Some people say it should clear the IconPixmapHint bit in this case,
5747 but that doesn't work, and the X consortium said it isn't the
5748 right thing at all. Since there is no way to win,
5749 best to explicitly give up. */
5751 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
5757 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
5758 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5761 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5765 #ifdef USE_X_TOOLKIT
5766 Window window
= XtWindow (f
->output_data
.x
->widget
);
5768 Window window
= FRAME_X_WINDOW (f
);
5771 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
5772 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
5773 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
5775 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
5779 /* Initialization. */
5781 #ifdef USE_X_TOOLKIT
5782 static XrmOptionDescRec emacs_options
[] = {
5783 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
5784 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
5786 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
5787 XrmoptionSepArg
, NULL
},
5788 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
5790 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5791 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5792 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5793 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5794 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5795 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
5796 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
5798 #endif /* USE_X_TOOLKIT */
5800 static int x_initialized
;
5803 /* Test whether two display-name strings agree up to the dot that separates
5804 the screen number from the server number. */
5806 same_x_server (name1
, name2
)
5807 char *name1
, *name2
;
5810 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
5814 if (seen_colon
&& *name1
== '.')
5818 && (*name1
== '.' || *name1
== '\0')
5819 && (*name2
== '.' || *name2
== '\0'));
5823 struct x_display_info
*
5824 x_term_init (display_name
, xrm_option
, resource_name
)
5825 Lisp_Object display_name
;
5827 char *resource_name
;
5833 struct x_display_info
*dpyinfo
;
5845 setlocale (LC_ALL
, "");
5846 /* In case we just overrode what init_lread did, redo it. */
5847 setlocale (LC_NUMERIC
, "C");
5848 setlocale (LC_TIME
, "C");
5851 #ifdef USE_X_TOOLKIT
5852 /* weiner@footloose.sps.mot.com reports that this causes
5854 X protocol error: BadAtom (invalid Atom parameter)
5855 on protocol request 18skiloaf.
5856 So let's not use it until R6. */
5858 XtSetLanguageProc (NULL
, NULL
, NULL
);
5869 argv
[argc
++] = "-xrm";
5870 argv
[argc
++] = xrm_option
;
5872 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
5873 resource_name
, EMACS_CLASS
,
5874 emacs_options
, XtNumber (emacs_options
),
5878 /* I think this is to compensate for XtSetLanguageProc. */
5879 setlocale (LC_NUMERIC
, "C");
5880 setlocale (LC_TIME
, "C");
5884 #else /* not USE_X_TOOLKIT */
5886 XSetLocaleModifiers ("");
5888 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
5889 #endif /* not USE_X_TOOLKIT */
5891 /* Detect failure. */
5898 /* We have definitely succeeded. Record the new connection. */
5900 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
5904 struct x_display_info
*share
;
5907 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
5908 share
= share
->next
, tail
= XCONS (tail
)->cdr
)
5909 if (same_x_server (XSTRING (XCONS (XCONS (tail
)->car
)->car
)->data
,
5910 XSTRING (display_name
)->data
))
5913 dpyinfo
->kboard
= share
->kboard
;
5916 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
5917 init_kboard (dpyinfo
->kboard
);
5918 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
5920 char *vendor
= ServerVendor (dpy
);
5921 dpyinfo
->kboard
->Vsystem_key_alist
5922 = call1 (Qvendor_specific_keysyms
,
5923 build_string (vendor
? vendor
: ""));
5926 dpyinfo
->kboard
->next_kboard
= all_kboards
;
5927 all_kboards
= dpyinfo
->kboard
;
5928 /* Don't let the initial kboard remain current longer than necessary.
5929 That would cause problems if a file loaded on startup tries to
5930 prompt in the minibuffer. */
5931 if (current_kboard
== initial_kboard
)
5932 current_kboard
= dpyinfo
->kboard
;
5934 dpyinfo
->kboard
->reference_count
++;
5938 /* Put this display on the chain. */
5939 dpyinfo
->next
= x_display_list
;
5940 x_display_list
= dpyinfo
;
5942 /* Put it on x_display_name_list as well, to keep them parallel. */
5943 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
5944 x_display_name_list
);
5945 dpyinfo
->name_list_element
= XCONS (x_display_name_list
)->car
;
5947 dpyinfo
->display
= dpy
;
5950 XSetAfterFunction (x_current_display
, x_trace_wire
);
5954 = (char *) xmalloc (XSTRING (Vinvocation_name
)->size
5955 + XSTRING (Vsystem_name
)->size
5957 sprintf (dpyinfo
->x_id_name
, "%s@%s",
5958 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
5960 /* Figure out which modifier bits mean what. */
5961 x_find_modifier_meanings (dpyinfo
);
5963 /* Get the scroll bar cursor. */
5964 dpyinfo
->vertical_scroll_bar_cursor
5965 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
5967 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
5968 resource_name
, EMACS_CLASS
);
5969 #ifdef HAVE_XRMSETDATABASE
5970 XrmSetDatabase (dpyinfo
->display
, xrdb
);
5972 dpyinfo
->display
->db
= xrdb
;
5974 /* Put the rdb where we can find it in a way that works on
5976 dpyinfo
->xrdb
= xrdb
;
5978 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
5979 DefaultScreen (dpyinfo
->display
));
5980 dpyinfo
->visual
= select_visual (dpyinfo
->display
, dpyinfo
->screen
,
5981 &dpyinfo
->n_planes
);
5982 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
5983 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
5984 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
5985 dpyinfo
->grabbed
= 0;
5986 dpyinfo
->reference_count
= 0;
5987 dpyinfo
->icon_bitmap_id
= -1;
5988 dpyinfo
->n_fonts
= 0;
5989 dpyinfo
->font_table_size
= 0;
5990 dpyinfo
->bitmaps
= 0;
5991 dpyinfo
->bitmaps_size
= 0;
5992 dpyinfo
->bitmaps_last
= 0;
5993 dpyinfo
->scratch_cursor_gc
= 0;
5994 dpyinfo
->mouse_face_mouse_frame
= 0;
5995 dpyinfo
->mouse_face_deferred_gc
= 0;
5996 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
5997 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
5998 dpyinfo
->mouse_face_face_id
= 0;
5999 dpyinfo
->mouse_face_window
= Qnil
;
6000 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
6001 dpyinfo
->mouse_face_defer
= 0;
6002 dpyinfo
->x_focus_frame
= 0;
6003 dpyinfo
->x_focus_event_frame
= 0;
6004 dpyinfo
->x_highlight_frame
= 0;
6006 dpyinfo
->Xatom_wm_protocols
6007 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
6008 dpyinfo
->Xatom_wm_take_focus
6009 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
6010 dpyinfo
->Xatom_wm_save_yourself
6011 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
6012 dpyinfo
->Xatom_wm_delete_window
6013 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
6014 dpyinfo
->Xatom_wm_change_state
6015 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
6016 dpyinfo
->Xatom_wm_configure_denied
6017 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
6018 dpyinfo
->Xatom_wm_window_moved
6019 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
6020 dpyinfo
->Xatom_editres
6021 = XInternAtom (dpyinfo
->display
, "Editres", False
);
6022 dpyinfo
->Xatom_CLIPBOARD
6023 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
6024 dpyinfo
->Xatom_TIMESTAMP
6025 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
6027 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
6028 dpyinfo
->Xatom_DELETE
6029 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
6030 dpyinfo
->Xatom_MULTIPLE
6031 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
6033 = XInternAtom (dpyinfo
->display
, "INCR", False
);
6034 dpyinfo
->Xatom_EMACS_TMP
6035 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
6036 dpyinfo
->Xatom_TARGETS
6037 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
6039 = XInternAtom (dpyinfo
->display
, "NULL", False
);
6040 dpyinfo
->Xatom_ATOM_PAIR
6041 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
6043 dpyinfo
->cut_buffers_initialized
= 0;
6045 connection
= ConnectionNumber (dpyinfo
->display
);
6046 dpyinfo
->connection
= connection
;
6049 /* This is only needed for distinguishing keyboard and process input. */
6050 if (connection
!= 0)
6051 add_keyboard_wait_descriptor (connection
);
6054 #ifndef F_SETOWN_BUG
6056 #ifdef F_SETOWN_SOCK_NEG
6057 /* stdin is a socket here */
6058 fcntl (connection
, F_SETOWN
, -getpid ());
6059 #else /* ! defined (F_SETOWN_SOCK_NEG) */
6060 fcntl (connection
, F_SETOWN
, getpid ());
6061 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
6062 #endif /* ! defined (F_SETOWN) */
6063 #endif /* F_SETOWN_BUG */
6066 if (interrupt_input
)
6067 init_sigio (connection
);
6068 #endif /* ! defined (SIGIO) */
6075 /* Get rid of display DPYINFO, assuming all frames are already gone,
6076 and without sending any more commands to the X server. */
6079 x_delete_display (dpyinfo
)
6080 struct x_display_info
*dpyinfo
;
6082 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
6084 /* Discard this display from x_display_name_list and x_display_list.
6085 We can't use Fdelq because that can quit. */
6086 if (! NILP (x_display_name_list
)
6087 && EQ (XCONS (x_display_name_list
)->car
, dpyinfo
->name_list_element
))
6088 x_display_name_list
= XCONS (x_display_name_list
)->cdr
;
6093 tail
= x_display_name_list
;
6094 while (CONSP (tail
) && CONSP (XCONS (tail
)->cdr
))
6096 if (EQ (XCONS (XCONS (tail
)->cdr
)->car
,
6097 dpyinfo
->name_list_element
))
6099 XCONS (tail
)->cdr
= XCONS (XCONS (tail
)->cdr
)->cdr
;
6102 tail
= XCONS (tail
)->cdr
;
6106 if (x_display_list
== dpyinfo
)
6107 x_display_list
= dpyinfo
->next
;
6110 struct x_display_info
*tail
;
6112 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
6113 if (tail
->next
== dpyinfo
)
6114 tail
->next
= tail
->next
->next
;
6117 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
6118 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
6119 XrmDestroyDatabase (dpyinfo
->xrdb
);
6123 if (--dpyinfo
->kboard
->reference_count
== 0)
6124 delete_kboard (dpyinfo
->kboard
);
6126 xfree (dpyinfo
->font_table
);
6127 xfree (dpyinfo
->x_id_name
);
6131 /* Set up use of X before we make the first connection. */
6135 clear_frame_hook
= XTclear_frame
;
6136 clear_end_of_line_hook
= XTclear_end_of_line
;
6137 ins_del_lines_hook
= XTins_del_lines
;
6138 change_line_highlight_hook
= XTchange_line_highlight
;
6139 insert_glyphs_hook
= XTinsert_glyphs
;
6140 write_glyphs_hook
= XTwrite_glyphs
;
6141 delete_glyphs_hook
= XTdelete_glyphs
;
6142 ring_bell_hook
= XTring_bell
;
6143 reset_terminal_modes_hook
= XTreset_terminal_modes
;
6144 set_terminal_modes_hook
= XTset_terminal_modes
;
6145 update_begin_hook
= XTupdate_begin
;
6146 update_end_hook
= XTupdate_end
;
6147 set_terminal_window_hook
= XTset_terminal_window
;
6148 read_socket_hook
= XTread_socket
;
6149 frame_up_to_date_hook
= XTframe_up_to_date
;
6150 cursor_to_hook
= XTcursor_to
;
6151 reassert_line_highlight_hook
= XTreassert_line_highlight
;
6152 mouse_position_hook
= XTmouse_position
;
6153 frame_rehighlight_hook
= XTframe_rehighlight
;
6154 frame_raise_lower_hook
= XTframe_raise_lower
;
6155 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
6156 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
6157 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
6158 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
6160 scroll_region_ok
= 1; /* we'll scroll partial frames */
6161 char_ins_del_ok
= 0; /* just as fast to write the line */
6162 line_ins_del_ok
= 1; /* we'll just blt 'em */
6163 fast_clear_end_of_line
= 1; /* X does this well */
6164 memory_below_frame
= 0; /* we don't remember what scrolls
6170 /* Try to use interrupt input; if we can't, then start polling. */
6171 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
6173 #ifdef USE_X_TOOLKIT
6174 XtToolkitInitialize ();
6175 Xt_app_con
= XtCreateApplicationContext ();
6176 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
6179 /* Note that there is no real way portable across R3/R4 to get the
6180 original error handler. */
6181 XSetErrorHandler (x_error_quitter
);
6182 XSetIOErrorHandler (x_io_error_quitter
);
6184 /* Disable Window Change signals; they are handled by X events. */
6186 signal (SIGWINCH
, SIG_DFL
);
6187 #endif /* ! defined (SIGWINCH) */
6189 signal (SIGPIPE
, x_connection_signal
);
6195 staticpro (&x_display_name_list
);
6196 x_display_name_list
= Qnil
;
6198 staticpro (&last_mouse_scroll_bar
);
6199 last_mouse_scroll_bar
= Qnil
;
6201 staticpro (&Qvendor_specific_keysyms
);
6202 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
6205 /* Avoid warnings or errors from including Xlibint.h.
6206 We don't need these functions for the rest of this file. */
6213 #ifdef X_CONNECTION_LOCK_FLAG
6214 #define free loserfree
6215 #define malloc losermalloc
6216 #define exit loserexit
6217 #define abort loserabort
6218 /* For XlibDisplayWriting */
6219 #include <X11/Xlibint.h>
6222 /* Check whether display connection DPYINFO is hung
6223 because its thread-interlock is locked.
6224 If it is, close the connection.
6225 Do nothing if this system does not have a thread interlock. */
6227 x_connection_close_if_hung (dpyinfo
)
6228 struct x_display_info
*dpyinfo
;
6230 /* This tests (1) whether X_CONNECTION_LOCK_FLAG is defined at all,
6231 and (2) whether the name it is defined as is itself defined.
6232 (It ought to have been defined by Xlibint.h. */
6233 #if X_CONNECTION_LOCK_FLAG
6235 if (dpyinfo
->display
->flags
& X_CONNECTION_LOCK_FLAG
)
6237 /* If the thread-interlock is locked, assume this connection is dead.
6238 This assumes that the library does not make other threads
6239 that can be locking the display legitimately. */
6241 dpyinfo
->display
->flags
&= ~X_CONNECTION_LOCK_FLAG
;
6242 x_connection_closed (dpyinfo
->display
, "connection was lost");
6244 #endif /* X_CONNECTION_LOCK_FLAG */
6247 /* Don't put any additional functions here! */
6249 #endif /* not HAVE_X_WINDOWS */