1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 1993, 1994 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Xt features made by Fred Pierresteguy. */
22 /* On 4.3 these lose if they come after xterm.h. */
23 /* On HP-UX 8.0 signal.h loses if it comes after config.h. */
24 /* Putting these at the beginning seems to be standard for other .c files. */
31 /* Need syssignal.h for various externs and definitions that may be required
32 by some configurations for calls to signal later in this source file. */
33 #include "syssignal.h"
38 #include "blockinput.h"
40 /* This may include sys/types.h, and that somehow loses
41 if this is not done before the other system files. */
43 #include <X11/cursorfont.h>
46 /* Load sys/types.h if not already loaded.
47 In some systems loading it twice is suicidal. */
49 #include <sys/types.h>
54 #include <sys/ioctl.h>
55 #endif /* ! defined (BSD) */
60 #ifndef INCLUDED_FCNTL
67 #include <sys/param.h>
69 #include "dispextern.h"
70 #include "termhooks.h"
83 #include "intervals.h"
86 extern XtAppContext Xt_app_con
;
87 extern Widget Xt_app_shell
;
88 extern void free_frame_menubar ();
89 extern void _XEditResCheckMessages ();
90 #endif /* USE_X_TOOLKIT */
93 #define x_any_window_to_frame x_window_to_frame
94 #define x_top_window_to_frame x_window_to_frame
98 #ifndef XtNinitialState
99 #define XtNinitialState "initialState"
103 #define XMapWindow XMapRaised /* Raise them when mapping. */
106 /* We could get this from param.h, but better not to depend on finding that.
107 And better not to risk that it might define other symbols used in this
110 #define MAXDESC FD_SETSIZE
114 #define SELECT_TYPE fd_set
115 #else /* no FD_SET */
117 #define SELECT_TYPE int
119 /* Define the macros to access a single-int bitmap of descriptors. */
120 #define FD_SET(n, p) (*(p) |= (1 << (n)))
121 #define FD_CLR(n, p) (*(p) &= ~(1 << (n)))
122 #define FD_ISSET(n, p) (*(p) & (1 << (n)))
123 #define FD_ZERO(p) (*(p) = 0)
124 #endif /* no FD_SET */
126 /* For sending Meta-characters. Do we need this? */
129 #define min(a,b) ((a)<(b) ? (a) : (b))
130 #define max(a,b) ((a)>(b) ? (a) : (b))
132 /* Nonzero means we must reprint all windows
133 because 1) we received an ExposeWindow event
134 or 2) we received too many ExposeRegion events to record.
136 This is never needed under X11. */
137 static int expose_all_windows
;
139 /* Nonzero means we must reprint all icon windows. */
141 static int expose_all_icons
;
143 #if defined (SIGIO) && defined (FIONREAD)
144 int BLOCK_INPUT_mask
;
145 #endif /* ! defined (SIGIO) && defined (FIONREAD) */
147 /* The id of a bitmap used for icon windows, in frames
148 for which no specific bitmap was specified.
149 This is 0 if we have not yet had a need to create the bitmap. */
151 static int icon_bitmap
;
153 /* Font used for text icons. */
155 static FONT_TYPE
*icon_font_info
;
157 /* Stuff for dealing with the main icon title. */
159 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
162 /* Initial values of argv and argc. */
163 extern char **initial_argv
;
164 extern int initial_argc
;
166 /* This is the X connection that we are using. */
168 Display
*x_current_display
;
170 /* The cursor to use for vertical scroll bars on x_current_display. */
171 static Cursor x_vertical_scroll_bar_cursor
;
173 /* Frame being updated by update_frame. This is declared in term.c.
174 This is set by update_begin and looked at by all the
175 XT functions. It is zero while not inside an update.
176 In that case, the XT functions assume that `selected_frame'
177 is the frame to apply to. */
178 extern struct frame
*updating_frame
;
180 /* The frame (if any) which has the X window that has keyboard focus.
181 Zero if none. This is examined by Ffocus_frame in frame.c. Note
182 that a mere EnterNotify event can set this; if you need to know the
183 last frame specified in a FocusIn or FocusOut event, use
184 x_focus_event_frame. */
185 struct frame
*x_focus_frame
;
187 /* This is a frame waiting to be autoraised, within XTread_socket. */
188 struct frame
*pending_autoraise_frame
;
190 /* The last frame mentioned in a FocusIn or FocusOut event. This is
191 separate from x_focus_frame, because whether or not LeaveNotify
192 events cause us to lose focus depends on whether or not we have
193 received a FocusIn event for it. */
194 struct frame
*x_focus_event_frame
;
196 /* The frame which currently has the visual highlight, and should get
197 keyboard input (other sorts of input have the frame encoded in the
198 event). It points to the X focus frame's selected window's
199 frame. It differs from x_focus_frame when we're using a global
201 static struct frame
*x_highlight_frame
;
203 /* From .Xdefaults, the value of "emacs.WarpMouse". If non-zero,
204 mouse is moved to inside of frame when frame is de-iconified. */
206 static int warp_mouse_on_deiconify
;
208 /* During an update, maximum vpos for ins/del line operations to affect. */
210 static int flexlines
;
212 /* During an update, nonzero if chars output now should be highlighted. */
214 static int highlight
;
216 /* Nominal cursor position -- where to draw output.
217 During an update, these are different from the cursor-box position. */
222 /* Reusable Graphics Context for drawing a cursor in a non-default face. */
223 static GC scratch_cursor_gc
;
227 In order to avoid asking for motion events and then throwing most
228 of them away or busy-polling the server for mouse positions, we ask
229 the server for pointer motion hints. This means that we get only
230 one event per group of mouse movements. "Groups" are delimited by
231 other kinds of events (focus changes and button clicks, for
232 example), or by XQueryPointer calls; when one of these happens, we
233 get another MotionNotify event the next time the mouse moves. This
234 is at least as efficient as getting motion events when mouse
235 tracking is on, and I suspect only negligibly worse when tracking
238 The silly O'Reilly & Associates Nutshell guides barely document
239 pointer motion hints at all (I think you have to infer how they
240 work from an example), and the description of XQueryPointer doesn't
241 mention that calling it causes you to get another motion hint from
242 the server, which is very important. */
244 /* Where the mouse was last time we reported a mouse event. */
245 static FRAME_PTR last_mouse_frame
;
246 static XRectangle last_mouse_glyph
;
248 /* The scroll bar in which the last X motion event occurred.
250 If the last X motion event occurred in a scroll bar, we set this
251 so XTmouse_position can know whether to report a scroll bar motion or
254 If the last X motion event didn't occur in a scroll bar, we set this
255 to Qnil, to tell XTmouse_position to return an ordinary motion event. */
256 static Lisp_Object last_mouse_scroll_bar
;
258 /* Record which buttons are currently pressed. */
259 unsigned int x_mouse_grabbed
;
261 /* This is a hack. We would really prefer that XTmouse_position would
262 return the time associated with the position it returns, but there
263 doesn't seem to be any way to wrest the timestamp from the server
264 along with the position query. So, we just keep track of the time
265 of the last movement we received, and return that in hopes that
266 it's somewhat accurate. */
267 static Time last_mouse_movement_time
;
269 /* These variables describe the range of text currently shown
270 in its mouse-face, together with the window they apply to.
271 As long as the mouse stays within this range, we need not
272 redraw anything on its account. */
273 static int mouse_face_beg_row
, mouse_face_beg_col
;
274 static int mouse_face_end_row
, mouse_face_end_col
;
275 static int mouse_face_past_end
;
276 static Lisp_Object mouse_face_window
;
277 static int mouse_face_face_id
;
279 /* 1 if a mouse motion event came and we didn't handle it right away because
280 gc was in progress. */
281 static int mouse_face_deferred_gc
;
283 /* FRAME and X, Y position of mouse when last checked for
284 highlighting. X and Y can be negative or out of range for the frame. */
285 static FRAME_PTR mouse_face_mouse_frame
;
286 static int mouse_face_mouse_x
, mouse_face_mouse_y
;
288 /* Nonzero means defer mouse-motion highlighting. */
289 static int mouse_face_defer
;
291 /* Incremented by XTread_socket whenever it really tries to read events. */
293 static int volatile input_signal_count
;
295 static int input_signal_count
;
298 /* `t' if a mouse button is depressed. */
300 extern Lisp_Object Vmouse_depressed
;
302 /* Tells if a window manager is present or not. */
304 extern Lisp_Object Vx_no_window_manager
;
306 /* Timestamp that we requested selection data was made. */
307 extern Time requestor_time
;
309 /* ID of the window requesting selection data. */
310 extern Window requestor_window
;
312 /* Nonzero enables some debugging for the X interface code. */
315 extern Lisp_Object Qface
, Qmouse_face
;
317 static int x_noop_count
;
320 /* From time to time we get info on an Emacs window, here. */
322 static WINDOWINFO_TYPE windowinfo
;
326 /* A mask of extra modifier bits to put into every keyboard char. */
327 extern int extra_keyboard_modifiers
;
329 extern Display
*XOpenDisplay ();
330 extern Window
XCreateWindow ();
332 extern Cursor
XCreateCursor ();
333 extern FONT_TYPE
*XOpenFont ();
335 static void flashback ();
336 static void redraw_previous_char ();
337 static void redraw_following_char ();
338 static unsigned int x_x_to_emacs_modifiers ();
340 static int fast_find_position ();
341 static void note_mouse_highlight ();
342 static void clear_mouse_face ();
343 static void show_mouse_face ();
344 static void do_line_dance ();
347 static int XTcursor_to ();
348 static int XTclear_end_of_line ();
351 /* Starting and ending updates.
353 These hooks are called by update_frame at the beginning and end
354 of a frame update. We record in `updating_frame' the identity
355 of the frame being updated, so that the XT... functions do not
356 need to take a frame as argument. Most of the XT... functions
357 should never be called except during an update, the only exceptions
358 being XTcursor_to, XTwrite_glyphs and XTreassert_line_highlight. */
360 extern int mouse_track_top
, mouse_track_left
, mouse_track_width
;
371 flexlines
= f
->height
;
376 if (f
== mouse_face_mouse_frame
)
378 /* Don't do highlighting for mouse motion during the update. */
379 mouse_face_defer
= 1;
380 if (!NILP (mouse_face_window
))
382 int firstline
, lastline
, i
;
383 struct window
*w
= XWINDOW (mouse_face_window
);
385 /* Find the first, and the last+1, lines affected by redisplay. */
386 for (firstline
= 0; firstline
< f
->height
; firstline
++)
387 if (FRAME_DESIRED_GLYPHS (f
)->enable
[firstline
])
390 lastline
= f
->height
;
391 for (i
= f
->height
- 1; i
>= 0; i
--)
393 if (FRAME_DESIRED_GLYPHS (f
)->enable
[i
])
399 /* Can we tell that this update does not affect the window
400 where the mouse highlight is? If so, no need to turn off. */
401 if (! (firstline
> (XFASTINT (w
->top
) + window_internal_height (w
))
402 || lastline
< XFASTINT (w
->top
)))
403 /* Otherwise turn off the mouse highlight now. */
420 x_display_cursor (f
, 1);
422 if (f
== mouse_face_mouse_frame
)
423 mouse_face_defer
= 0;
425 /* This fails in the case of having updated only the echo area
426 if we have switched buffers. In that case, FRAME_CURRENT_GLYPHS
427 has no relation to the current contents, and its charstarts
428 have no relation to the contents of the window-buffer.
429 I don't know a clean way to check
430 for that case. window_end_valid isn't set up yet. */
431 if (f
== mouse_face_mouse_frame
)
432 note_mouse_highlight (f
, mouse_face_mouse_x
, mouse_face_mouse_y
);
439 /* This is called after a redisplay on frame F. */
442 XTframe_up_to_date (f
)
445 if (mouse_face_deferred_gc
|| f
== mouse_face_mouse_frame
)
447 note_mouse_highlight (mouse_face_mouse_frame
,
448 mouse_face_mouse_x
, mouse_face_mouse_y
);
449 mouse_face_deferred_gc
= 0;
453 /* External interface to control of standout mode.
454 Call this when about to modify line at position VPOS
455 and not change whether it is highlighted. */
457 XTreassert_line_highlight (new, vpos
)
463 /* Call this when about to modify line at position VPOS
464 and change whether it is highlighted. */
467 XTchange_line_highlight (new_highlight
, vpos
, first_unused_hpos
)
468 int new_highlight
, vpos
, first_unused_hpos
;
470 highlight
= new_highlight
;
471 XTcursor_to (vpos
, 0);
472 XTclear_end_of_line (updating_frame
->width
);
475 /* This is used when starting Emacs and when restarting after suspend.
476 When starting Emacs, no X window is mapped. And nothing must be done
477 to Emacs's own window if it is suspended (though that rarely happens). */
480 XTset_terminal_modes ()
484 /* This is called when exiting or suspending Emacs.
485 Exiting will make the X-windows go away, and suspending
486 requires no action. */
489 XTreset_terminal_modes ()
491 /* XTclear_frame (); */
494 /* Set the nominal cursor position of the frame.
495 This is where display update commands will take effect.
496 This does not affect the place where the cursor-box is displayed. */
499 XTcursor_to (row
, col
)
500 register int row
, col
;
508 if (updating_frame
== 0)
511 x_display_cursor (selected_frame
, 1);
517 /* Display a sequence of N glyphs found at GP.
518 WINDOW is the x-window to output to. LEFT and TOP are starting coords.
519 HL is 1 if this text is highlighted, 2 if the cursor is on it,
520 3 if should appear in its mouse-face.
521 JUST_FOREGROUND if 1 means draw only the foreground;
522 don't alter the background.
524 FONT is the default font to use (for glyphs whose font-code is 0).
526 Since the display generation code is responsible for calling
527 compute_char_face and compute_glyph_face on everything it puts in
528 the display structure, we can assume that the face code on each
529 glyph is a valid index into FRAME_COMPUTED_FACES (f), and the one
530 to which we can actually apply intern_face.
531 Call this function with input blocked. */
534 /* This is the multi-face code. */
537 dumpglyphs (f
, left
, top
, gp
, n
, hl
, just_foreground
)
540 register GLYPH
*gp
; /* Points to first GLYPH. */
541 register int n
; /* Number of glyphs to display. */
545 /* Holds characters to be displayed. */
546 char *buf
= (char *) alloca (f
->width
* sizeof (*buf
));
547 register char *cp
; /* Steps through buf[]. */
548 register int tlen
= GLYPH_TABLE_LENGTH
;
549 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
550 Window window
= FRAME_X_WINDOW (f
);
551 int orig_left
= left
;
555 /* Get the face-code of the next GLYPH. */
559 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
560 cf
= FAST_GLYPH_FACE (g
);
562 /* Find the run of consecutive glyphs with the same face-code.
563 Extract their character codes into BUF. */
568 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
569 if (FAST_GLYPH_FACE (g
) != cf
)
572 *cp
++ = FAST_GLYPH_CHAR (g
);
577 /* LEN gets the length of the run. */
580 /* Now output this run of chars, with the font and pixel values
581 determined by the face code CF. */
583 struct face
*face
= FRAME_DEFAULT_FACE (f
);
584 FONT_TYPE
*font
= FACE_FONT (face
);
585 GC gc
= FACE_GC (face
);
587 /* HL = 3 means use a mouse face previously chosen. */
589 cf
= mouse_face_face_id
;
591 /* First look at the face of the text itself. */
594 /* It's possible for the display table to specify
595 a face code that is out of range. Use 0 in that case. */
596 if (cf
< 0 || cf
>= FRAME_N_COMPUTED_FACES (f
)
597 || FRAME_COMPUTED_FACES (f
) [cf
] == 0)
601 face
= FRAME_MODE_LINE_FACE (f
);
603 face
= intern_face (f
, FRAME_COMPUTED_FACES (f
) [cf
]);
604 font
= FACE_FONT (face
);
608 /* Then comes the distinction between modeline and normal text. */
613 face
= FRAME_MODE_LINE_FACE (f
);
614 font
= FACE_FONT (face
);
618 #define FACE_DEFAULT (~0)
620 /* Now override that if the cursor's on this character. */
624 || (int) face
->font
== FACE_DEFAULT
625 || face
->font
== f
->display
.x
->font
)
626 && face
->background
== f
->display
.x
->background_pixel
627 && face
->foreground
== f
->display
.x
->foreground_pixel
)
629 gc
= f
->display
.x
->cursor_gc
;
631 /* Cursor on non-default face: must merge. */
637 xgcv
.background
= f
->display
.x
->cursor_pixel
;
638 xgcv
.foreground
= face
->background
;
639 /* If the glyph would be invisible,
640 try a different foreground. */
641 if (xgcv
.foreground
== xgcv
.background
)
642 xgcv
.foreground
= face
->foreground
;
643 if (xgcv
.foreground
== xgcv
.background
)
644 xgcv
.foreground
= f
->display
.x
->cursor_foreground_pixel
;
645 if (xgcv
.foreground
== xgcv
.background
)
646 xgcv
.foreground
= face
->foreground
;
647 /* Make sure the cursor is distinct from text in this face. */
648 if (xgcv
.background
== face
->background
649 && xgcv
.foreground
== face
->foreground
)
651 xgcv
.background
= face
->foreground
;
652 xgcv
.foreground
= face
->background
;
654 xgcv
.font
= face
->font
->fid
;
655 xgcv
.graphics_exposures
= 0;
656 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
657 if (scratch_cursor_gc
)
658 XChangeGC (x_current_display
, scratch_cursor_gc
, mask
, &xgcv
);
661 XCreateGC (x_current_display
, window
, mask
, &xgcv
);
662 gc
= scratch_cursor_gc
;
664 /* If this code is restored, it must also reset to the default stipple
666 if (face
->stipple
&& face
->stipple
!= FACE_DEFAULT
)
667 XSetStipple (x_current_display
, gc
, face
->stipple
);
672 if ((int) font
== FACE_DEFAULT
)
673 font
= f
->display
.x
->font
;
676 XDrawString (x_current_display
, window
, gc
,
677 left
, top
+ FONT_BASE (font
), buf
, len
);
680 XDrawImageString (x_current_display
, window
, gc
,
681 left
, top
+ FONT_BASE (font
), buf
, len
);
682 /* Clear the rest of the line's height. */
683 if (f
->display
.x
->line_height
!= FONT_HEIGHT (font
))
684 XClearArea (x_current_display
, window
, left
,
685 top
+ FONT_HEIGHT (font
),
686 FONT_WIDTH (font
) * len
,
687 /* This is how many pixels of height
689 f
->display
.x
->line_height
- FONT_HEIGHT (font
),
693 #if 0 /* Doesn't work, because it uses FRAME_CURRENT_GLYPHS,
694 which often is not up to date yet. */
695 if (!just_foreground
)
697 if (left
== orig_left
)
698 redraw_previous_char (f
, PIXEL_TO_CHAR_COL (f
, left
),
699 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
701 redraw_following_char (f
, PIXEL_TO_CHAR_COL (f
, left
+ len
* FONT_WIDTH (font
)),
702 PIXEL_TO_CHAR_ROW (f
, top
), hl
== 1);
706 /* We should probably check for XA_UNDERLINE_POSITION and
707 XA_UNDERLINE_THICKNESS properties on the font, but let's
708 just get the thing working, and come back to that. */
710 int underline_position
= 1;
712 if (font
->descent
<= underline_position
)
713 underline_position
= font
->descent
- 1;
716 XFillRectangle (x_current_display
, FRAME_X_WINDOW (f
),
720 + underline_position
),
721 len
* FONT_WIDTH (font
), 1);
724 left
+= len
* FONT_WIDTH (font
);
731 /* This is the old single-face code. */
734 dumpglyphs (f
, left
, top
, gp
, n
, hl
, font
)
737 register GLYPH
*gp
; /* Points to first GLYPH. */
738 register int n
; /* Number of glyphs to display. */
743 Window window
= FRAME_X_WINDOW (f
);
744 GC drawing_gc
= (hl
== 2 ? f
->display
.x
->cursor_gc
745 : (hl
? f
->display
.x
->reverse_gc
746 : f
->display
.x
->normal_gc
));
748 if (sizeof (GLYPH
) == sizeof (XChar2b
))
749 XDrawImageString16 (x_current_display
, window
, drawing_gc
,
750 left
, top
+ FONT_BASE (font
), (XChar2b
*) gp
, n
);
751 else if (sizeof (GLYPH
) == sizeof (unsigned char))
752 XDrawImageString (x_current_display
, window
, drawing_gc
,
753 left
, top
+ FONT_BASE (font
), (char *) gp
, n
);
755 /* What size of glyph ARE you using? And does X have a function to
761 /* Output some text at the nominal frame cursor position.
762 Advance the cursor over the text.
763 Output LEN glyphs at START.
765 `highlight', set up by XTreassert_line_highlight or XTchange_line_highlight,
766 controls the pixel values used for foreground and background. */
769 XTwrite_glyphs (start
, len
)
770 register GLYPH
*start
;
773 register int temp_length
;
784 /* If not within an update,
785 output at the frame's visible cursor. */
786 curs_x
= f
->cursor_x
;
787 curs_y
= f
->cursor_y
;
791 CHAR_TO_PIXEL_COL (f
, curs_x
),
792 CHAR_TO_PIXEL_ROW (f
, curs_y
),
793 start
, len
, highlight
, 0);
795 /* If we drew on top of the cursor, note that it is turned off. */
796 if (curs_y
== f
->phys_cursor_y
797 && curs_x
<= f
->phys_cursor_x
798 && curs_x
+ len
> f
->phys_cursor_x
)
799 f
->phys_cursor_x
= -1;
801 if (updating_frame
== 0)
804 x_display_cursor (f
, 1);
813 /* Clear to the end of the line.
814 Erase the current text line from the nominal cursor position (inclusive)
815 to column FIRST_UNUSED (exclusive). The idea is that everything
816 from FIRST_UNUSED onward is already erased. */
819 XTclear_end_of_line (first_unused
)
820 register int first_unused
;
822 struct frame
*f
= updating_frame
;
828 if (curs_y
< 0 || curs_y
>= f
->height
)
830 if (first_unused
<= 0)
833 if (first_unused
>= f
->width
)
834 first_unused
= f
->width
;
838 /* Notice if the cursor will be cleared by this operation. */
839 if (curs_y
== f
->phys_cursor_y
840 && curs_x
<= f
->phys_cursor_x
841 && f
->phys_cursor_x
< first_unused
)
842 f
->phys_cursor_x
= -1;
844 XClearArea (x_current_display
, FRAME_X_WINDOW (f
),
845 CHAR_TO_PIXEL_COL (f
, curs_x
),
846 CHAR_TO_PIXEL_ROW (f
, curs_y
),
847 FONT_WIDTH (f
->display
.x
->font
) * (first_unused
- curs_x
),
848 f
->display
.x
->line_height
, False
);
850 redraw_previous_char (f
, curs_x
, curs_y
, highlight
);
860 struct frame
*f
= updating_frame
;
865 f
->phys_cursor_x
= -1; /* Cursor not visible. */
866 curs_x
= 0; /* Nominal cursor position is top left. */
871 XClear (FRAME_X_WINDOW (f
));
873 /* We have to clear the scroll bars, too. If we have changed
874 colors or something like that, then they should be notified. */
875 x_scroll_bar_clear (f
);
882 /* This currently does not work because FRAME_CURRENT_GLYPHS doesn't
883 always contain the right glyphs to use.
885 It also needs to be changed to look at the details of the font and
886 see whether there is really overlap, and do nothing when there is
887 not. This can use font_char_overlap_left and font_char_overlap_right,
888 but just how to use them is not clear. */
890 /* Erase the character (if any) at the position just before X, Y in frame F,
891 then redraw it and the character before it.
892 This is necessary when we erase starting at X,
893 in case the character after X overlaps into the one before X.
894 Call this function with input blocked. */
897 redraw_previous_char (f
, x
, y
, highlight_flag
)
902 /* Erase the character before the new ones, in case
903 what was here before overlaps it.
904 Reoutput that character, and the previous character
905 (in case the previous character overlaps it). */
911 XClearArea (x_current_display
, FRAME_X_WINDOW (f
),
912 CHAR_TO_PIXEL_COL (f
, x
- 1),
913 CHAR_TO_PIXEL_ROW (f
, y
),
914 FONT_WIDTH (f
->display
.x
->font
),
915 f
->display
.x
->line_height
, False
);
917 dumpglyphs (f
, CHAR_TO_PIXEL_COL (f
, start_x
),
918 CHAR_TO_PIXEL_ROW (f
, y
),
919 &FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][start_x
],
920 x
- start_x
, highlight_flag
, 1);
924 /* Erase the character (if any) at the position X, Y in frame F,
925 then redraw it and the character after it.
926 This is necessary when we erase endng at X,
927 in case the character after X overlaps into the one before X.
928 Call this function with input blocked. */
931 redraw_following_char (f
, x
, y
, highlight_flag
)
936 int limit
= FRAME_CURRENT_GLYPHS (f
)->used
[y
];
937 /* Erase the character after the new ones, in case
938 what was here before overlaps it.
939 Reoutput that character, and the following character
940 (in case the following character overlaps it). */
942 && FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][x
] != SPACEGLYPH
)
947 XClearArea (x_current_display
, FRAME_X_WINDOW (f
),
948 CHAR_TO_PIXEL_COL (f
, x
),
949 CHAR_TO_PIXEL_ROW (f
, y
),
950 FONT_WIDTH (f
->display
.x
->font
),
951 f
->display
.x
->line_height
, False
);
953 dumpglyphs (f
, CHAR_TO_PIXEL_COL (f
, x
),
954 CHAR_TO_PIXEL_ROW (f
, y
),
955 &FRAME_CURRENT_GLYPHS (f
)->glyphs
[y
][x
],
956 end_x
- x
, highlight_flag
, 1);
961 #if 0 /* Not in use yet */
963 /* Return 1 if character C in font F extends past its left edge. */
966 font_char_overlap_left (font
, c
)
972 /* Find the bounding-box info for C. */
973 if (font
->per_char
== 0)
974 s
= &font
->max_bounds
;
977 int rowlen
= font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1;
980 /* Decode char into row number (byte 1) and code within row (byte 2). */
983 if (!(within
>= font
->min_char_or_byte2
984 && within
<= font
->max_char_or_byte2
985 && row
>= font
->min_byte1
986 && row
<= font
->max_byte1
))
988 /* If char is out of range, try the font's default char instead. */
989 c
= font
->default_char
;
990 row
= c
>> (INTBITS
- 8);
993 if (!(within
>= font
->min_char_or_byte2
994 && within
<= font
->max_char_or_byte2
995 && row
>= font
->min_byte1
996 && row
<= font
->max_byte1
))
997 /* Still out of range means this char does not overlap. */
1000 /* We found the info for this char. */
1001 s
= (font
->per_char
+ (within
- font
->min_char_or_byte2
)
1005 return (s
&& s
->lbearing
< 0);
1008 /* Return 1 if character C in font F extends past its right edge. */
1011 font_char_overlap_right (font
, c
)
1017 /* Find the bounding-box info for C. */
1018 if (font
->per_char
== 0)
1019 s
= &font
->max_bounds
;
1022 int rowlen
= font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1;
1025 /* Decode char into row number (byte 1) and code within row (byte 2). */
1028 if (!(within
>= font
->min_char_or_byte2
1029 && within
<= font
->max_char_or_byte2
1030 && row
>= font
->min_byte1
1031 && row
<= font
->max_byte1
))
1033 /* If char is out of range, try the font's default char instead. */
1034 c
= font
->default_char
;
1035 row
= c
>> (INTBITS
- 8);
1038 if (!(within
>= font
->min_char_or_byte2
1039 && within
<= font
->max_char_or_byte2
1040 && row
>= font
->min_byte1
1041 && row
<= font
->max_byte1
))
1042 /* Still out of range means this char does not overlap. */
1045 /* We found the info for this char. */
1046 s
= (font
->per_char
+ (within
- font
->min_char_or_byte2
)
1050 return (s
&& s
->rbearing
>= s
->width
);
1054 /* Invert the middle quarter of the frame for .15 sec. */
1056 /* We use the select system call to do the waiting, so we have to make sure
1057 it's available. If it isn't, we just won't do visual bells. */
1058 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
1060 /* Subtract the `struct timeval' values X and Y,
1061 storing the result in RESULT.
1062 Return 1 if the difference is negative, otherwise 0. */
1065 timeval_subtract (result
, x
, y
)
1066 struct timeval
*result
, x
, y
;
1068 /* Perform the carry for the later subtraction by updating y.
1069 This is safer because on some systems
1070 the tv_sec member is unsigned. */
1071 if (x
.tv_usec
< y
.tv_usec
)
1073 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
1074 y
.tv_usec
-= 1000000 * nsec
;
1077 if (x
.tv_usec
- y
.tv_usec
> 1000000)
1079 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
1080 y
.tv_usec
+= 1000000 * nsec
;
1084 /* Compute the time remaining to wait. tv_usec is certainly positive. */
1085 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
1086 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
1088 /* Return indication of whether the result should be considered negative. */
1089 return x
.tv_sec
< y
.tv_sec
;
1100 /* Create a GC that will use the GXxor function to flip foreground pixels
1101 into background pixels. */
1105 values
.function
= GXxor
;
1106 values
.foreground
= (f
->display
.x
->foreground_pixel
1107 ^ f
->display
.x
->background_pixel
);
1109 gc
= XCreateGC (x_current_display
, FRAME_X_WINDOW (f
),
1110 GCFunction
| GCForeground
, &values
);
1114 int width
= PIXEL_WIDTH (f
);
1115 int height
= PIXEL_HEIGHT (f
);
1117 XFillRectangle (x_current_display
, FRAME_X_WINDOW (f
), gc
,
1118 width
/4, height
/4, width
/2, height
/2);
1119 XFlush (x_current_display
);
1122 struct timeval wakeup
, now
;
1124 EMACS_GET_TIME (wakeup
);
1126 /* Compute time to wait until, propagating carry from usecs. */
1127 wakeup
.tv_usec
+= 150000;
1128 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
1129 wakeup
.tv_usec
%= 1000000;
1131 /* Keep waiting until past the time wakeup. */
1134 struct timeval timeout
;
1136 EMACS_GET_TIME (timeout
);
1138 /* In effect, timeout = wakeup - timeout.
1139 Break if result would be negative. */
1140 if (timeval_subtract (&timeout
, wakeup
, timeout
))
1143 /* Try to wait that long--but we might wake up sooner. */
1144 select (0, 0, 0, 0, &timeout
);
1148 XFillRectangle (x_current_display
, FRAME_X_WINDOW (f
), gc
,
1149 width
/4, height
/4, width
/2, height
/2);
1150 XFreeGC (x_current_display
, gc
);
1151 XFlush (x_current_display
);
1161 /* Make audible bell. */
1163 #define XRINGBELL XBell (x_current_display, 0)
1167 if (x_current_display
== 0)
1170 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
1172 XTflash (selected_frame
);
1183 /* Insert and delete character.
1184 These are not supposed to be used because we are supposed to turn
1185 off the feature of using them. */
1188 XTinsert_glyphs (start
, len
)
1189 register char *start
;
1202 /* Specify how many text lines, from the top of the window,
1203 should be affected by insert-lines and delete-lines operations.
1204 This, and those operations, are used only within an update
1205 that is bounded by calls to XTupdate_begin and XTupdate_end. */
1208 XTset_terminal_window (n
)
1211 if (updating_frame
== 0)
1214 if ((n
<= 0) || (n
> updating_frame
->height
))
1215 flexlines
= updating_frame
->height
;
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
->display
.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 (x_current_display
, FRAME_X_WINDOW (f
),
1306 FRAME_X_WINDOW (f
), f
->display
.x
->normal_gc
,
1307 intborder
, CHAR_TO_PIXEL_ROW (f
, i
+distance
),
1308 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
1309 (j
-i
) * f
->display
.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
); --j
);
1319 /* Copy (j,i] downward from (j+distance, i+distance] */
1320 XCopyArea (x_current_display
, FRAME_X_WINDOW (f
),
1321 FRAME_X_WINDOW (f
), f
->display
.x
->normal_gc
,
1322 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1+distance
),
1323 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
1324 (i
-j
) * f
->display
.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 (x_current_display
, FRAME_X_WINDOW (f
),
1335 intborder
, CHAR_TO_PIXEL_ROW (f
, i
),
1336 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
1337 (j
-i
) * f
->display
.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
->display
.x
->line_height
- 1);
1374 right
+= (FONT_WIDTH (f
->display
.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);
1428 frame_highlight (frame
)
1429 struct frame
*frame
;
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 (x_current_display
, FRAME_X_WINDOW (frame
),
1437 frame
->display
.x
->border_pixel
);
1439 x_display_cursor (frame
, 1);
1443 frame_unhighlight (frame
)
1444 struct frame
*frame
;
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 (x_current_display
, FRAME_X_WINDOW (frame
),
1452 frame
->display
.x
->border_tile
);
1454 x_display_cursor (frame
, 1);
1457 static void XTframe_rehighlight ();
1459 /* The focus has changed. Update the frames as necessary to reflect
1460 the new situation. Note that we can't change the selected frame
1461 here, because the lisp code we are interrupting might become confused.
1462 Each event gets marked with the frame in which it occurred, so the
1463 lisp code can tell when the switch took place by examining the events. */
1466 x_new_focus_frame (frame
)
1467 struct frame
*frame
;
1469 struct frame
*old_focus
= x_focus_frame
;
1470 int events_enqueued
= 0;
1472 if (frame
!= x_focus_frame
)
1474 /* Set this before calling other routines, so that they see
1475 the correct value of x_focus_frame. */
1476 x_focus_frame
= frame
;
1478 if (old_focus
&& old_focus
->auto_lower
)
1479 x_lower_frame (old_focus
);
1482 selected_frame
= frame
;
1483 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
1485 Fselect_window (selected_frame
->selected_window
);
1486 choose_minibuf_frame ();
1489 if (x_focus_frame
&& x_focus_frame
->auto_raise
)
1490 pending_autoraise_frame
= x_focus_frame
;
1492 pending_autoraise_frame
= 0;
1495 XTframe_rehighlight ();
1499 /* The focus has changed, or we have redirected a frame's focus to
1500 another frame (this happens when a frame uses a surrogate
1501 minibuffer frame). Shift the highlight as appropriate. */
1503 XTframe_rehighlight ()
1505 struct frame
*old_highlight
= x_highlight_frame
;
1510 ((XGCTYPE (FRAME_FOCUS_FRAME (x_focus_frame
)) == Lisp_Frame
)
1511 ? XFRAME (FRAME_FOCUS_FRAME (x_focus_frame
))
1513 if (! FRAME_LIVE_P (x_highlight_frame
))
1515 FRAME_FOCUS_FRAME (x_focus_frame
) = Qnil
;
1516 x_highlight_frame
= x_focus_frame
;
1520 x_highlight_frame
= 0;
1522 if (x_highlight_frame
!= old_highlight
)
1525 frame_unhighlight (old_highlight
);
1526 if (x_highlight_frame
)
1527 frame_highlight (x_highlight_frame
);
1531 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
1533 /* Which modifier keys are on which modifier bits?
1535 With each keystroke, X returns eight bits indicating which modifier
1536 keys were held down when the key was pressed. The interpretation
1537 of the top five modifier bits depends on what keys are attached
1538 to them. If the Meta_L and Meta_R keysyms are on mod5, then mod5
1541 x_meta_mod_mask is a mask containing the bits used for the meta key.
1542 It may have more than one bit set, if more than one modifier bit
1543 has meta keys on it. Basically, if EVENT is a KeyPress event,
1544 the meta key is pressed if (EVENT.state & x_meta_mod_mask) != 0.
1546 x_shift_lock_mask is LockMask if the XK_Shift_Lock keysym is on the
1547 lock modifier bit, or zero otherwise. Non-alphabetic keys should
1548 only be affected by the lock modifier bit if XK_Shift_Lock is in
1549 use; XK_Caps_Lock should only affect alphabetic keys. With this
1550 arrangement, the lock modifier should shift the character if
1551 (EVENT.state & x_shift_lock_mask) != 0. */
1552 static int x_meta_mod_mask
, x_shift_lock_mask
;
1554 /* These are like x_meta_mod_mask, but for different modifiers. */
1555 static int x_alt_mod_mask
, x_super_mod_mask
, x_hyper_mod_mask
;
1557 /* Initialize mode_switch_bit and modifier_meaning. */
1559 x_find_modifier_meanings ()
1561 int min_code
, max_code
;
1564 XModifierKeymap
*mods
;
1566 x_meta_mod_mask
= 0;
1567 x_shift_lock_mask
= 0;
1569 x_super_mod_mask
= 0;
1570 x_hyper_mod_mask
= 0;
1573 XDisplayKeycodes (x_current_display
, &min_code
, &max_code
);
1575 min_code
= x_current_display
->min_keycode
;
1576 max_code
= x_current_display
->max_keycode
;
1579 syms
= XGetKeyboardMapping (x_current_display
,
1580 min_code
, max_code
- min_code
+ 1,
1582 mods
= XGetModifierMapping (x_current_display
);
1584 /* Scan the modifier table to see which modifier bits the Meta and
1585 Alt keysyms are on. */
1587 int row
, col
; /* The row and column in the modifier table. */
1589 for (row
= 3; row
< 8; row
++)
1590 for (col
= 0; col
< mods
->max_keypermod
; col
++)
1593 mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
1595 /* Zeroes are used for filler. Skip them. */
1599 /* Are any of this keycode's keysyms a meta key? */
1603 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
1605 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
1611 x_meta_mod_mask
|= (1 << row
);
1616 x_alt_mod_mask
|= (1 << row
);
1621 x_hyper_mod_mask
|= (1 << row
);
1626 x_super_mod_mask
|= (1 << row
);
1630 /* Ignore this if it's not on the lock modifier. */
1631 if ((1 << row
) == LockMask
)
1632 x_shift_lock_mask
= LockMask
;
1640 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
1641 if (! x_meta_mod_mask
)
1643 x_meta_mod_mask
= x_alt_mod_mask
;
1647 /* If some keys are both alt and meta,
1648 make them just meta, not alt. */
1649 if (x_alt_mod_mask
& x_meta_mod_mask
)
1651 x_alt_mod_mask
&= ~x_meta_mod_mask
;
1654 XFree ((char *) syms
);
1655 XFreeModifiermap (mods
);
1658 /* Convert between the modifier bits X uses and the modifier bits
1661 x_x_to_emacs_modifiers (state
)
1664 return ( ((state
& (ShiftMask
| x_shift_lock_mask
)) ? shift_modifier
: 0)
1665 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
1666 | ((state
& x_meta_mod_mask
) ? meta_modifier
: 0)
1667 | ((state
& x_alt_mod_mask
) ? alt_modifier
: 0)
1668 | ((state
& x_super_mod_mask
) ? super_modifier
: 0)
1669 | ((state
& x_hyper_mod_mask
) ? hyper_modifier
: 0));
1673 x_emacs_to_x_modifiers (state
)
1676 return ( ((state
& alt_modifier
) ? x_alt_mod_mask
: 0)
1677 | ((state
& super_modifier
) ? x_super_mod_mask
: 0)
1678 | ((state
& hyper_modifier
) ? x_hyper_mod_mask
: 0)
1679 | ((state
& shift_modifier
) ? ShiftMask
: 0)
1680 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
1681 | ((state
& meta_modifier
) ? x_meta_mod_mask
: 0));
1684 /* Mouse clicks and mouse movement. Rah. */
1686 /* Given a pixel position (PIX_X, PIX_Y) on the frame F, return
1687 glyph co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle
1688 that the glyph at X, Y occupies, if BOUNDS != 0.
1689 If NOCLIP is nonzero, do not force the value into range. */
1692 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
1694 register int pix_x
, pix_y
;
1695 register int *x
, *y
;
1699 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
1700 even for negative values. */
1702 pix_x
-= FONT_WIDTH ((f
)->display
.x
->font
) - 1;
1704 pix_y
-= (f
)->display
.x
->line_height
- 1;
1706 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
1707 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
1711 bounds
->width
= FONT_WIDTH (f
->display
.x
->font
);
1712 bounds
->height
= f
->display
.x
->line_height
;
1713 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
1714 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
1721 else if (pix_x
> f
->width
)
1726 else if (pix_y
> f
->height
)
1735 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
1738 register int *pix_x
, *pix_y
;
1740 *pix_x
= CHAR_TO_PIXEL_COL (f
, x
);
1741 *pix_y
= CHAR_TO_PIXEL_ROW (f
, y
);
1744 /* Prepare a mouse-event in *RESULT for placement in the input queue.
1746 If the event is a button press, then note that we have grabbed
1750 construct_mouse_click (result
, event
, f
)
1751 struct input_event
*result
;
1752 XButtonEvent
*event
;
1755 /* Make the event type no_event; we'll change that when we decide
1757 result
->kind
= mouse_click
;
1758 result
->code
= event
->button
- Button1
;
1759 result
->timestamp
= event
->time
;
1760 result
->modifiers
= (x_x_to_emacs_modifiers (event
->state
)
1761 | (event
->type
== ButtonRelease
1769 pixel_to_glyph_coords (f
, event
->x
, event
->y
, &column
, &row
, NULL
, 0);
1770 XSETFASTINT (result
->x
, column
);
1771 XSETFASTINT (result
->y
, row
);
1773 XSETINT (result
->x
, event
->x
);
1774 XSETINT (result
->y
, event
->y
);
1775 XSETFRAME (result
->frame_or_window
, f
);
1779 /* Prepare a menu-event in *RESULT for placement in the input queue. */
1782 construct_menu_click (result
, event
, f
)
1783 struct input_event
*result
;
1784 XButtonEvent
*event
;
1787 /* Make the event type no_event; we'll change that when we decide
1789 result
->kind
= mouse_click
;
1790 XSETINT (result
->code
, event
->button
- Button1
);
1791 result
->timestamp
= event
->time
;
1792 result
->modifiers
= (x_x_to_emacs_modifiers (event
->state
)
1793 | (event
->type
== ButtonRelease
1797 XSETINT (result
->x
, event
->x
);
1798 XSETINT (result
->y
, -1);
1799 XSETFRAME (result
->frame_or_window
, f
);
1802 /* Function to report a mouse movement to the mainstream Emacs code.
1803 The input handler calls this.
1805 We have received a mouse movement event, which is given in *event.
1806 If the mouse is over a different glyph than it was last time, tell
1807 the mainstream emacs code by setting mouse_moved. If not, ask for
1808 another motion event, so we can check again the next time it moves. */
1811 note_mouse_movement (frame
, event
)
1813 XMotionEvent
*event
;
1816 last_mouse_movement_time
= event
->time
;
1818 if (event
->window
!= FRAME_X_WINDOW (frame
))
1821 last_mouse_scroll_bar
= Qnil
;
1823 note_mouse_highlight (frame
, -1, -1);
1825 /* Ask for another mouse motion event. */
1828 Window dummy_window
;
1830 XQueryPointer (event
->display
, FRAME_X_WINDOW (frame
),
1831 &dummy_window
, &dummy_window
,
1832 &dummy
, &dummy
, &dummy
, &dummy
,
1833 (unsigned int *) &dummy
);
1837 /* Has the mouse moved off the glyph it was on at the last sighting? */
1838 else if (event
->x
< last_mouse_glyph
.x
1839 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
1840 || event
->y
< last_mouse_glyph
.y
1841 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
1844 last_mouse_scroll_bar
= Qnil
;
1846 note_mouse_highlight (frame
, event
->x
, event
->y
);
1848 /* Ask for another mouse motion event. */
1851 Window dummy_window
;
1853 XQueryPointer (event
->display
, FRAME_X_WINDOW (frame
),
1854 &dummy_window
, &dummy_window
,
1855 &dummy
, &dummy
, &dummy
, &dummy
,
1856 (unsigned int *) &dummy
);
1861 /* It's on the same glyph. Call XQueryPointer so we'll get an
1862 event the next time the mouse moves and we can see if it's
1863 *still* on the same glyph. */
1865 Window dummy_window
;
1867 XQueryPointer (event
->display
, FRAME_X_WINDOW (frame
),
1868 &dummy_window
, &dummy_window
,
1869 &dummy
, &dummy
, &dummy
, &dummy
,
1870 (unsigned int *) &dummy
);
1874 /* This is used for debugging, to turn off note_mouse_highlight. */
1875 static int disable_mouse_highlight
;
1877 /* Take proper action when the mouse has moved to position X, Y on frame F
1878 as regards highlighting characters that have mouse-face properties.
1879 Also dehighlighting chars where the mouse was before.
1880 X and Y can be negative or out of range. */
1883 note_mouse_highlight (f
, x
, y
)
1886 int row
, column
, portion
;
1887 XRectangle new_glyph
;
1891 if (disable_mouse_highlight
)
1894 mouse_face_mouse_x
= x
;
1895 mouse_face_mouse_y
= y
;
1896 mouse_face_mouse_frame
= f
;
1898 if (mouse_face_defer
)
1903 mouse_face_deferred_gc
= 1;
1907 /* Find out which glyph the mouse is on. */
1908 pixel_to_glyph_coords (f
, x
, y
, &column
, &row
,
1909 &new_glyph
, x_mouse_grabbed
);
1911 /* Which window is that in? */
1912 window
= window_from_coordinates (f
, column
, row
, &portion
);
1913 w
= XWINDOW (window
);
1915 /* If we were displaying active text in another window, clear that. */
1916 if (! EQ (window
, mouse_face_window
))
1917 clear_mouse_face ();
1919 /* Are we in a window whose display is up to date?
1920 And verify the buffer's text has not changed. */
1921 if (WINDOWP (window
) && portion
== 0 && row
>= 0 && column
>= 0
1922 && row
< FRAME_HEIGHT (f
) && column
< FRAME_WIDTH (f
)
1923 && EQ (w
->window_end_valid
, w
->buffer
)
1924 && w
->last_modified
== BUF_MODIFF (XBUFFER (w
->buffer
)))
1926 int *ptr
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[row
];
1929 /* Find which buffer position the mouse corresponds to. */
1930 for (i
= column
; i
>= 0; i
--)
1934 /* Is it outside the displayed active region (if any)? */
1936 clear_mouse_face ();
1937 else if (! (EQ (window
, mouse_face_window
)
1938 && row
>= mouse_face_beg_row
1939 && row
<= mouse_face_end_row
1940 && (row
> mouse_face_beg_row
|| column
>= mouse_face_beg_col
)
1941 && (row
< mouse_face_end_row
|| column
< mouse_face_end_col
1942 || mouse_face_past_end
)))
1944 Lisp_Object mouse_face
, overlay
, position
;
1945 Lisp_Object
*overlay_vec
;
1946 int len
, noverlays
, ignor1
;
1947 struct buffer
*obuf
;
1950 /* If we get an out-of-range value, return now; avoid an error. */
1951 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1954 /* Make the window's buffer temporarily current for
1955 overlays_at and compute_char_face. */
1956 obuf
= current_buffer
;
1957 current_buffer
= XBUFFER (w
->buffer
);
1963 /* Yes. Clear the display of the old active region, if any. */
1964 clear_mouse_face ();
1966 /* Is this char mouse-active? */
1967 XSETINT (position
, pos
);
1970 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1972 /* Put all the overlays we want in a vector in overlay_vec.
1973 Store the length in len. */
1974 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
1976 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1978 /* Find the highest priority overlay that has a mouse-face prop. */
1980 for (i
= 0; i
< noverlays
; i
++)
1982 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1983 if (!NILP (mouse_face
))
1985 overlay
= overlay_vec
[i
];
1990 /* If no overlay applies, get a text property. */
1992 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
1994 /* Handle the overlay case. */
1995 if (! NILP (overlay
))
1997 /* Find the range of text around this char that
1998 should be active. */
1999 Lisp_Object before
, after
;
2002 before
= Foverlay_start (overlay
);
2003 after
= Foverlay_end (overlay
);
2004 /* Record this as the current active region. */
2005 fast_find_position (window
, before
, &mouse_face_beg_col
,
2006 &mouse_face_beg_row
);
2008 = !fast_find_position (window
, after
, &mouse_face_end_col
,
2009 &mouse_face_end_row
);
2010 mouse_face_window
= window
;
2011 mouse_face_face_id
= compute_char_face (f
, w
, pos
, 0, 0,
2012 &ignore
, pos
+ 1, 1);
2014 /* Display it as active. */
2015 show_mouse_face (1);
2017 /* Handle the text property case. */
2018 else if (! NILP (mouse_face
))
2020 /* Find the range of text around this char that
2021 should be active. */
2022 Lisp_Object before
, after
, beginning
, end
;
2025 beginning
= Fmarker_position (w
->start
);
2026 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
2027 - XFASTINT (w
->window_end_pos
)));
2029 = Fprevious_single_property_change (make_number (pos
+ 1),
2031 w
->buffer
, beginning
);
2033 = Fnext_single_property_change (position
, Qmouse_face
,
2035 /* Record this as the current active region. */
2036 fast_find_position (window
, before
, &mouse_face_beg_col
,
2037 &mouse_face_beg_row
);
2039 = !fast_find_position (window
, after
, &mouse_face_end_col
,
2040 &mouse_face_end_row
);
2041 mouse_face_window
= window
;
2043 = compute_char_face (f
, w
, pos
, 0, 0,
2044 &ignore
, pos
+ 1, 1);
2046 /* Display it as active. */
2047 show_mouse_face (1);
2051 current_buffer
= obuf
;
2056 /* Find the row and column of position POS in window WINDOW.
2057 Store them in *COLUMNP and *ROWP.
2058 This assumes display in WINDOW is up to date.
2059 If POS is above start of WINDOW, return coords
2060 of start of first screen line.
2061 If POS is after end of WINDOW, return coords of end of last screen line.
2063 Value is 1 if POS is in range, 0 if it was off screen. */
2066 fast_find_position (window
, pos
, columnp
, rowp
)
2069 int *columnp
, *rowp
;
2071 struct window
*w
= XWINDOW (window
);
2072 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2077 int height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
2078 int width
= window_internal_width (w
);
2082 /* Find the right row. */
2087 int linestart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ i
][left
];
2088 if (linestart
> pos
)
2094 /* Find the right column with in it. */
2095 charstarts
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ row
];
2097 for (i
= 0; i
< width
; i
++)
2099 if (charstarts
[left
+ i
] == pos
)
2102 *columnp
= i
+ left
;
2105 else if (charstarts
[left
+ i
] > pos
)
2107 else if (charstarts
[left
+ i
] > 0)
2116 /* Display the active region described by mouse_face_*
2117 in its mouse-face if HL > 0, in its normal face if HL = 0. */
2120 show_mouse_face (hl
)
2123 struct window
*w
= XWINDOW (mouse_face_window
);
2124 int width
= window_internal_width (w
);
2125 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2128 int old_curs_x
= curs_x
;
2129 int old_curs_y
= curs_y
;
2131 /* Set these variables temporarily
2132 so that if we have to turn the cursor off and on again
2133 we will put it back at the same place. */
2134 curs_x
= f
->phys_cursor_x
;
2135 curs_y
= f
->phys_cursor_y
;
2137 for (i
= mouse_face_beg_row
; i
<= mouse_face_end_row
; i
++)
2139 int column
= (i
== mouse_face_beg_row
? mouse_face_beg_col
: w
->left
);
2140 int endcolumn
= (i
== mouse_face_end_row
? mouse_face_end_col
: w
->left
+ width
);
2141 endcolumn
= min (endcolumn
, FRAME_CURRENT_GLYPHS (f
)->used
[i
]);
2143 /* If the cursor's in the text we are about to rewrite,
2144 turn the cursor off. */
2146 && curs_x
>= mouse_face_beg_col
- 1 && curs_x
<= mouse_face_end_col
)
2148 x_display_cursor (f
, 0);
2153 CHAR_TO_PIXEL_COL (f
, column
),
2154 CHAR_TO_PIXEL_ROW (f
, i
),
2155 FRAME_CURRENT_GLYPHS (f
)->glyphs
[i
] + column
,
2157 /* Highlight with mouse face if hl > 0. */
2161 /* If we turned the cursor off, turn it back on. */
2163 x_display_cursor (f
, 1);
2165 curs_x
= old_curs_x
;
2166 curs_y
= old_curs_y
;
2168 /* Change the mouse cursor according to the value of HL. */
2170 XDefineCursor (XDISPLAY
FRAME_X_WINDOW (f
), f
->display
.x
->cross_cursor
);
2172 XDefineCursor (XDISPLAY
FRAME_X_WINDOW (f
), f
->display
.x
->text_cursor
);
2175 /* Clear out the mouse-highlighted active region.
2176 Redraw it unhighlighted first. */
2181 if (! NILP (mouse_face_window
))
2182 show_mouse_face (0);
2184 mouse_face_beg_row
= mouse_face_beg_col
= -1;
2185 mouse_face_end_row
= mouse_face_end_col
= -1;
2186 mouse_face_window
= Qnil
;
2189 static struct scroll_bar
*x_window_to_scroll_bar ();
2190 static void x_scroll_bar_report_motion ();
2192 /* Return the current position of the mouse.
2194 If the mouse movement started in a scroll bar, set *f, *bar_window,
2195 and *part to the frame, window, and scroll bar part that the mouse
2196 is over. Set *x and *y to the portion and whole of the mouse's
2197 position on the scroll bar.
2199 If the mouse movement started elsewhere, set *f to the frame the
2200 mouse is on, *bar_window to nil, and *x and *y to the character cell
2203 Set *time to the server timestamp for the time at which the mouse
2204 was at this position.
2206 Don't store anything if we don't have a valid set of values to report.
2208 This clears the mouse_moved flag, so we can wait for the next mouse
2209 movement. This also calls XQueryPointer, which will cause the
2210 server to give us another MotionNotify when the mouse moves
2214 XTmouse_position (f
, bar_window
, part
, x
, y
, time
)
2216 Lisp_Object
*bar_window
;
2217 enum scroll_bar_part
*part
;
2219 unsigned long *time
;
2225 if (! NILP (last_mouse_scroll_bar
))
2226 x_scroll_bar_report_motion (f
, bar_window
, part
, x
, y
, time
);
2232 Window dummy_window
;
2236 last_mouse_scroll_bar
= Qnil
;
2238 /* Figure out which root window we're on. */
2239 XQueryPointer (x_current_display
,
2240 DefaultRootWindow (x_current_display
),
2242 /* The root window which contains the pointer. */
2245 /* Trash which we can't trust if the pointer is on
2246 a different screen. */
2249 /* The position on that root window. */
2252 /* More trash we can't trust. */
2255 /* Modifier keys and pointer buttons, about which
2257 (unsigned int *) &dummy
);
2259 /* Now we have a position on the root; find the innermost window
2260 containing the pointer. */
2264 int parent_x
, parent_y
;
2268 if (x_mouse_grabbed
&& last_mouse_frame
2269 && FRAME_LIVE_P (last_mouse_frame
))
2271 /* If mouse was grabbed on a frame, give coords for that frame
2272 even if the mouse is now outside it. */
2273 XTranslateCoordinates (x_current_display
,
2275 /* From-window, to-window. */
2276 root
, FRAME_X_WINDOW (last_mouse_frame
),
2278 /* From-position, to-position. */
2279 root_x
, root_y
, &win_x
, &win_y
,
2283 f1
= last_mouse_frame
;
2289 XTranslateCoordinates (x_current_display
,
2291 /* From-window, to-window. */
2294 /* From-position, to-position. */
2295 root_x
, root_y
, &win_x
, &win_y
,
2308 /* Now we know that:
2309 win is the innermost window containing the pointer
2310 (XTC says it has no child containing the pointer),
2311 win_x and win_y are the pointer's position in it
2312 (XTC did this the last time through), and
2313 parent_x and parent_y are the pointer's position in win's parent.
2314 (They are what win_x and win_y were when win was child.
2315 If win is the root window, it has no parent, and
2316 parent_{x,y} are invalid, but that's okay, because we'll
2317 never use them in that case.) */
2319 /* Is win one of our frames? */
2320 f1
= x_any_window_to_frame (win
);
2323 /* If not, is it one of our scroll bars? */
2326 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
2330 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2338 int ignore1
, ignore2
;
2340 /* Ok, we found a frame. Store all the values. */
2342 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
2343 &last_mouse_glyph
, x_mouse_grabbed
);
2348 XSETINT (*x
, win_x
);
2349 XSETINT (*y
, win_y
);
2350 *time
= last_mouse_movement_time
;
2358 /* Scroll bar support. */
2360 /* Given an X window ID, find the struct scroll_bar which manages it.
2361 This can be called in GC, so we have to make sure to strip off mark
2363 static struct scroll_bar
*
2364 x_window_to_scroll_bar (window_id
)
2367 Lisp_Object tail
, frame
;
2369 for (tail
= Vframe_list
;
2370 XGCTYPE (tail
) == Lisp_Cons
;
2371 tail
= XCONS (tail
)->cdr
)
2373 Lisp_Object frame
, bar
, condemned
;
2375 frame
= XCONS (tail
)->car
;
2376 /* All elements of Vframe_list should be frames. */
2377 if (XGCTYPE (frame
) != Lisp_Frame
)
2380 /* Scan this frame's scroll bar list for a scroll bar with the
2382 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
2383 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
2384 /* This trick allows us to search both the ordinary and
2385 condemned scroll bar lists with one loop. */
2386 ! GC_NILP (bar
) || (bar
= condemned
,
2389 bar
= XSCROLL_BAR (bar
)->next
)
2390 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
2391 return XSCROLL_BAR (bar
);
2397 /* Open a new X window to serve as a scroll bar, and return the
2398 scroll bar vector for it. */
2399 static struct scroll_bar
*
2400 x_scroll_bar_create (window
, top
, left
, width
, height
)
2401 struct window
*window
;
2402 int top
, left
, width
, height
;
2404 FRAME_PTR frame
= XFRAME (WINDOW_FRAME (window
));
2405 struct scroll_bar
*bar
=
2406 XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
2411 XSetWindowAttributes a
;
2413 a
.background_pixel
= frame
->display
.x
->background_pixel
;
2414 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
2415 | ButtonMotionMask
| PointerMotionHintMask
2417 a
.cursor
= x_vertical_scroll_bar_cursor
;
2419 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
2424 XtSetArg (al
[ac
], XtNx
, left
); ac
++;
2425 XtSetArg (al
[ac
], XtNy
, top
); ac
++;
2426 XtSetArg (al
[ac
], XtNwidth
, width
); ac
++;
2427 XtSetArg (al
[ac
], XtNheight
, height
); ac
++;
2428 XtSetArg (al
[ac
], XtNborderWidth
, 0); ac
++;
2429 sb_widget
= XtCreateManagedWidget ("box",
2431 frame
->display
.x
->edit_widget
, al
, ac
);
2432 SET_SCROLL_BAR_X_WINDOW
2433 (bar
, sb_widget
->core
.window
);
2435 SET_SCROLL_BAR_X_WINDOW
2437 XCreateWindow (x_current_display
, FRAME_X_WINDOW (frame
),
2439 /* Position and size of scroll bar. */
2440 left
, top
, width
, height
,
2442 /* Border width, depth, class, and visual. */
2443 0, CopyFromParent
, CopyFromParent
, CopyFromParent
,
2449 XSETWINDOW (bar
->window
, window
);
2450 XSETINT (bar
->top
, top
);
2451 XSETINT (bar
->left
, left
);
2452 XSETINT (bar
->width
, width
);
2453 XSETINT (bar
->height
, height
);
2454 XSETINT (bar
->start
, 0);
2455 XSETINT (bar
->end
, 0);
2456 bar
->dragging
= Qnil
;
2458 /* Add bar to its frame's list of scroll bars. */
2459 bar
->next
= FRAME_SCROLL_BARS (frame
);
2461 XSETVECTOR (FRAME_SCROLL_BARS (frame
), bar
);
2462 if (! NILP (bar
->next
))
2463 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2465 XMapWindow (x_current_display
, SCROLL_BAR_X_WINDOW (bar
));
2472 /* Draw BAR's handle in the proper position.
2473 If the handle is already drawn from START to END, don't bother
2474 redrawing it, unless REBUILD is non-zero; in that case, always
2475 redraw it. (REBUILD is handy for drawing the handle after expose
2478 Normally, we want to constrain the start and end of the handle to
2479 fit inside its rectangle, but if the user is dragging the scroll bar
2480 handle, we want to let them drag it down all the way, so that the
2481 bar's top is as far down as it goes; otherwise, there's no way to
2482 move to the very end of the buffer. */
2484 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
2485 struct scroll_bar
*bar
;
2489 int dragging
= ! NILP (bar
->dragging
);
2490 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2491 GC gc
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))->display
.x
->normal_gc
;
2493 /* If the display is already accurate, do nothing. */
2495 && start
== XINT (bar
->start
)
2496 && end
== XINT (bar
->end
))
2502 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (XINT (bar
->width
));
2503 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2504 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2506 /* Make sure the values are reasonable, and try to preserve
2507 the distance between start and end. */
2509 int length
= end
- start
;
2513 else if (start
> top_range
)
2515 end
= start
+ length
;
2519 else if (end
> top_range
&& ! dragging
)
2523 /* Store the adjusted setting in the scroll bar. */
2524 XSETINT (bar
->start
, start
);
2525 XSETINT (bar
->end
, end
);
2527 /* Clip the end position, just for display. */
2528 if (end
> top_range
)
2531 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
2532 below top positions, to make sure the handle is always at least
2533 that many pixels tall. */
2534 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
2536 /* Draw the empty space above the handle. Note that we can't clear
2537 zero-height areas; that means "clear to end of window." */
2539 XClearArea (x_current_display
, w
,
2541 /* x, y, width, height, and exposures. */
2542 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2543 VERTICAL_SCROLL_BAR_TOP_BORDER
,
2544 inside_width
, start
,
2547 /* Draw the handle itself. */
2548 XFillRectangle (x_current_display
, w
, gc
,
2550 /* x, y, width, height */
2551 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2552 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
2553 inside_width
, end
- start
);
2556 /* Draw the empty space below the handle. Note that we can't
2557 clear zero-height areas; that means "clear to end of window." */
2558 if (end
< inside_height
)
2559 XClearArea (x_current_display
, w
,
2561 /* x, y, width, height, and exposures. */
2562 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2563 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
2564 inside_width
, inside_height
- end
,
2572 /* Move a scroll bar around on the screen, to accommodate changing
2573 window configurations. */
2575 x_scroll_bar_move (bar
, top
, left
, width
, height
)
2576 struct scroll_bar
*bar
;
2577 int top
, left
, width
, height
;
2583 unsigned int mask
= 0;
2590 if (left
!= XINT (bar
->left
)) mask
|= CWX
;
2591 if (top
!= XINT (bar
->top
)) mask
|= CWY
;
2592 if (width
!= XINT (bar
->width
)) mask
|= CWWidth
;
2593 if (height
!= XINT (bar
->height
)) mask
|= CWHeight
;
2596 XConfigureWindow (x_current_display
, SCROLL_BAR_X_WINDOW (bar
),
2600 XSETINT (bar
->left
, left
);
2601 XSETINT (bar
->top
, top
);
2602 XSETINT (bar
->width
, width
);
2603 XSETINT (bar
->height
, height
);
2608 /* Destroy the X window for BAR, and set its Emacs window's scroll bar
2611 x_scroll_bar_remove (bar
)
2612 struct scroll_bar
*bar
;
2614 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2618 /* Destroy the window. */
2619 XDestroyWindow (x_current_display
, SCROLL_BAR_X_WINDOW (bar
));
2621 /* Disassociate this scroll bar from its window. */
2622 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
2627 /* Set the handle of the vertical scroll bar for WINDOW to indicate
2628 that we are displaying PORTION characters out of a total of WHOLE
2629 characters, starting at POSITION. If WINDOW has no scroll bar,
2632 XTset_vertical_scroll_bar (window
, portion
, whole
, position
)
2633 struct window
*window
;
2634 int portion
, whole
, position
;
2636 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2637 int top
= XINT (window
->top
);
2638 int left
= WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window
);
2639 int height
= WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window
);
2641 /* Where should this scroll bar be, pixelwise? */
2642 int pixel_top
= CHAR_TO_PIXEL_ROW (f
, top
);
2643 int pixel_left
= CHAR_TO_PIXEL_COL (f
, left
);
2645 = (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
2646 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
2647 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->display
.x
->font
)));
2648 int pixel_height
= VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f
, height
);
2650 struct scroll_bar
*bar
;
2652 /* Does the scroll bar exist yet? */
2653 if (NILP (window
->vertical_scroll_bar
))
2654 bar
= x_scroll_bar_create (window
,
2655 pixel_top
, pixel_left
,
2656 pixel_width
, pixel_height
);
2659 /* It may just need to be moved and resized. */
2660 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2661 x_scroll_bar_move (bar
, pixel_top
, pixel_left
, pixel_width
, pixel_height
);
2664 /* Set the scroll bar's current state, unless we're currently being
2666 if (NILP (bar
->dragging
))
2669 VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height
);
2672 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
2675 int start
= ((double) position
* top_range
) / whole
;
2676 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
2678 x_scroll_bar_set_handle (bar
, start
, end
, 0);
2682 XSETVECTOR (window
->vertical_scroll_bar
, bar
);
2686 /* The following three hooks are used when we're doing a thorough
2687 redisplay of the frame. We don't explicitly know which scroll bars
2688 are going to be deleted, because keeping track of when windows go
2689 away is a real pain - "Can you say set-window-configuration, boys
2690 and girls?" Instead, we just assert at the beginning of redisplay
2691 that *all* scroll bars are to be removed, and then save a scroll bar
2692 from the fiery pit when we actually redisplay its window. */
2694 /* Arrange for all scroll bars on FRAME to be removed at the next call
2695 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
2696 `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
2698 XTcondemn_scroll_bars (frame
)
2701 /* The condemned list should be empty at this point; if it's not,
2702 then the rest of Emacs isn't using the condemn/redeem/judge
2703 protocol correctly. */
2704 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
2707 /* Move them all to the "condemned" list. */
2708 FRAME_CONDEMNED_SCROLL_BARS (frame
) = FRAME_SCROLL_BARS (frame
);
2709 FRAME_SCROLL_BARS (frame
) = Qnil
;
2712 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
2713 Note that WINDOW isn't necessarily condemned at all. */
2715 XTredeem_scroll_bar (window
)
2716 struct window
*window
;
2718 struct scroll_bar
*bar
;
2720 /* We can't redeem this window's scroll bar if it doesn't have one. */
2721 if (NILP (window
->vertical_scroll_bar
))
2724 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2726 /* Unlink it from the condemned list. */
2728 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2730 if (NILP (bar
->prev
))
2732 /* If the prev pointer is nil, it must be the first in one of
2734 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
2735 /* It's not condemned. Everything's fine. */
2737 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
2738 window
->vertical_scroll_bar
))
2739 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
2741 /* If its prev pointer is nil, it must be at the front of
2742 one or the other! */
2746 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
2748 if (! NILP (bar
->next
))
2749 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
2751 bar
->next
= FRAME_SCROLL_BARS (f
);
2753 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2754 if (! NILP (bar
->next
))
2755 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2759 /* Remove all scroll bars on FRAME that haven't been saved since the
2760 last call to `*condemn_scroll_bars_hook'. */
2762 XTjudge_scroll_bars (f
)
2765 Lisp_Object bar
, next
;
2767 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
2769 /* Clear out the condemned list now so we won't try to process any
2770 more events on the hapless scroll bars. */
2771 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
2773 for (; ! NILP (bar
); bar
= next
)
2775 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
2777 x_scroll_bar_remove (b
);
2780 b
->next
= b
->prev
= Qnil
;
2783 /* Now there should be no references to the condemned scroll bars,
2784 and they should get garbage-collected. */
2788 /* Handle an Expose or GraphicsExpose event on a scroll bar.
2790 This may be called from a signal handler, so we have to ignore GC
2793 x_scroll_bar_expose (bar
, event
)
2794 struct scroll_bar
*bar
;
2797 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2798 GC gc
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))->display
.x
->normal_gc
;
2802 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
2804 /* Draw a one-pixel border just inside the edges of the scroll bar. */
2805 XDrawRectangle (x_current_display
, w
, gc
,
2807 /* x, y, width, height */
2808 0, 0, XINT (bar
->width
) - 1, XINT (bar
->height
) - 1);
2813 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
2814 is set to something other than no_event, it is enqueued.
2816 This may be called from a signal handler, so we have to ignore GC
2819 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
2820 struct scroll_bar
*bar
;
2822 struct input_event
*emacs_event
;
2824 if (XGCTYPE (bar
->window
) != Lisp_Window
)
2827 emacs_event
->kind
= scroll_bar_click
;
2828 emacs_event
->code
= event
->xbutton
.button
- Button1
;
2829 emacs_event
->modifiers
=
2830 (x_x_to_emacs_modifiers (event
->xbutton
.state
)
2831 | (event
->type
== ButtonRelease
2834 emacs_event
->frame_or_window
= bar
->window
;
2835 emacs_event
->timestamp
= event
->xbutton
.time
;
2837 int internal_height
=
2838 VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2840 VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2841 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
2844 if (y
> top_range
) y
= top_range
;
2846 if (y
< XINT (bar
->start
))
2847 emacs_event
->part
= scroll_bar_above_handle
;
2848 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
2849 emacs_event
->part
= scroll_bar_handle
;
2851 emacs_event
->part
= scroll_bar_below_handle
;
2853 /* Just because the user has clicked on the handle doesn't mean
2854 they want to drag it. Lisp code needs to be able to decide
2855 whether or not we're dragging. */
2857 /* If the user has just clicked on the handle, record where they're
2859 if (event
->type
== ButtonPress
2860 && emacs_event
->part
== scroll_bar_handle
)
2861 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
2864 /* If the user has released the handle, set it to its final position. */
2865 if (event
->type
== ButtonRelease
2866 && ! NILP (bar
->dragging
))
2868 int new_start
= y
- XINT (bar
->dragging
);
2869 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2871 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2872 bar
->dragging
= Qnil
;
2875 /* Same deal here as the other #if 0. */
2877 /* Clicks on the handle are always reported as occurring at the top of
2879 if (emacs_event
->part
== scroll_bar_handle
)
2880 emacs_event
->x
= bar
->start
;
2882 XSETINT (emacs_event
->x
, y
);
2884 XSETINT (emacs_event
->x
, y
);
2887 XSETINT (emacs_event
->y
, top_range
);
2891 /* Handle some mouse motion while someone is dragging the scroll bar.
2893 This may be called from a signal handler, so we have to ignore GC
2896 x_scroll_bar_note_movement (bar
, event
)
2897 struct scroll_bar
*bar
;
2900 last_mouse_movement_time
= event
->xmotion
.time
;
2903 XSETVECTOR (last_mouse_scroll_bar
, bar
);
2905 /* If we're dragging the bar, display it. */
2906 if (! GC_NILP (bar
->dragging
))
2908 /* Where should the handle be now? */
2909 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
2911 if (new_start
!= XINT (bar
->start
))
2913 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2915 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2919 /* Call XQueryPointer so we'll get an event the next time the mouse
2920 moves and we can see *still* on the same position. */
2923 Window dummy_window
;
2925 XQueryPointer (event
->xmotion
.display
, event
->xmotion
.window
,
2926 &dummy_window
, &dummy_window
,
2927 &dummy
, &dummy
, &dummy
, &dummy
,
2928 (unsigned int *) &dummy
);
2932 /* Return information to the user about the current position of the mouse
2933 on the scroll bar. */
2935 x_scroll_bar_report_motion (f
, bar_window
, part
, x
, y
, time
)
2937 Lisp_Object
*bar_window
;
2938 enum scroll_bar_part
*part
;
2940 unsigned long *time
;
2942 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
2944 Window dummy_window
;
2946 unsigned int dummy_mask
;
2950 /* Get the mouse's position relative to the scroll bar window, and
2952 if (! XQueryPointer (x_current_display
,
2953 SCROLL_BAR_X_WINDOW (bar
),
2955 /* Root, child, root x and root y. */
2956 &dummy_window
, &dummy_window
,
2957 &dummy_coord
, &dummy_coord
,
2959 /* Position relative to scroll bar. */
2962 /* Mouse buttons and modifier keys. */
2968 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2970 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2972 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
2974 if (! NILP (bar
->dragging
))
2975 win_y
-= XINT (bar
->dragging
);
2979 if (win_y
> top_range
)
2982 *f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2983 *bar_window
= bar
->window
;
2985 if (! NILP (bar
->dragging
))
2986 *part
= scroll_bar_handle
;
2987 else if (win_y
< XINT (bar
->start
))
2988 *part
= scroll_bar_above_handle
;
2989 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
2990 *part
= scroll_bar_handle
;
2992 *part
= scroll_bar_below_handle
;
2994 XSETINT (*x
, win_y
);
2995 XSETINT (*y
, top_range
);
2998 last_mouse_scroll_bar
= Qnil
;
3001 *time
= last_mouse_movement_time
;
3007 /* The screen has been cleared so we may have changed foreground or
3008 background colors, and the scroll bars may need to be redrawn.
3009 Clear out the scroll bars, and ask for expose events, so we can
3012 x_scroll_bar_clear (f
)
3017 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
3018 bar
= XSCROLL_BAR (bar
)->next
)
3019 XClearArea (x_current_display
, SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
3023 /* This processes Expose events from the menubar specific X event
3024 loop in menubar.c. This allows to redisplay the frame if necessary
3025 when handling menubar or popup items. */
3028 process_expose_from_menu (event
)
3035 f
= x_window_to_frame (event
.xexpose
.window
);
3038 if (f
->async_visible
== 0)
3040 f
->async_visible
= 1;
3041 f
->async_iconified
= 0;
3042 SET_FRAME_GARBAGED (f
);
3046 dumprectangle (x_window_to_frame (event
.xexpose
.window
),
3047 event
.xexpose
.x
, event
.xexpose
.y
,
3048 event
.xexpose
.width
, event
.xexpose
.height
);
3053 struct scroll_bar
*bar
3054 = x_window_to_scroll_bar (event
.xexpose
.window
);
3057 x_scroll_bar_expose (bar
, &event
);
3063 /* Define a queue to save up SelectionRequest events for later handling. */
3065 struct selection_event_queue
3068 struct selection_event_queue
*next
;
3071 static struct selection_event_queue
*queue
;
3073 /* Nonzero means queue up certain events--don't process them yet. */
3074 static int x_queue_selection_requests
;
3076 /* Queue up an X event *EVENT, to be processed later. */
3079 x_queue_event (event
)
3082 struct selection_event_queue
*queue_tmp
3083 = (struct selection_event_queue
*) malloc (sizeof (struct selection_event_queue
));
3085 if (queue_tmp
!= NULL
)
3087 queue_tmp
->event
= *event
;
3088 queue_tmp
->next
= queue
;
3093 /* Take all the queued events and put them back
3094 so that they get processed afresh. */
3099 while (queue
!= NULL
)
3101 struct selection_event_queue
*queue_tmp
= queue
;
3102 XPutBackEvent (XDISPLAY
&queue_tmp
->event
);
3103 queue
= queue_tmp
->next
;
3104 free ((char *)queue_tmp
);
3108 /* Start queuing SelectionRequest events. */
3111 x_start_queuing_selection_requests ()
3113 x_queue_selection_requests
++;
3116 /* Stop queuing SelectionRequest events. */
3119 x_stop_queuing_selection_requests ()
3121 x_queue_selection_requests
--;
3122 x_unqueue_events ();
3125 /* The main X event-reading loop - XTread_socket. */
3127 /* Timestamp of enter window event. This is only used by XTread_socket,
3128 but we have to put it out here, since static variables within functions
3129 sometimes don't work. */
3130 static Time enter_timestamp
;
3132 /* This holds the state XLookupString needs to implement dead keys
3133 and other tricks known as "compose processing". _X Window System_
3134 says that a portable program can't use this, but Stephen Gildea assures
3135 me that letting the compiler initialize it to zeros will work okay.
3137 This must be defined outside of XTread_socket, for the same reasons
3138 given for enter_timestamp, above. */
3139 static XComposeStatus compose_status
;
3141 /* Communication with window managers. */
3142 Atom Xatom_wm_protocols
;
3144 /* Kinds of protocol things we may receive. */
3145 Atom Xatom_wm_take_focus
;
3146 Atom Xatom_wm_save_yourself
;
3147 Atom Xatom_wm_delete_window
;
3149 /* Other WM communication */
3150 Atom Xatom_wm_configure_denied
; /* When our config request is denied */
3151 Atom Xatom_wm_window_moved
; /* When the WM moves us. */
3153 /* Window manager communication. */
3154 Atom Xatom_wm_change_state
;
3156 /* EditRes protocol */
3157 Atom Xatom_editres_name
;
3159 /* Record the last 100 characters stored
3160 to help debug the loss-of-chars-during-GC problem. */
3162 short temp_buffer
[100];
3164 /* Read events coming from the X server.
3165 This routine is called by the SIGIO handler.
3166 We return as soon as there are no more events to be read.
3168 Events representing keys are stored in buffer BUFP,
3169 which can hold up to NUMCHARS characters.
3170 We return the number of characters stored into the buffer,
3171 thus pretending to be `read'.
3173 WAITP is nonzero if we should block until input arrives.
3174 EXPECTED is nonzero if the caller knows input is available. */
3177 XTread_socket (sd
, bufp
, numchars
, waitp
, expected
)
3179 register struct input_event
*bufp
;
3180 register int numchars
;
3187 int items_pending
; /* How many items are in the X queue. */
3190 int event_found
= 0;
3194 if (interrupt_input_blocked
)
3196 interrupt_input_pending
= 1;
3200 interrupt_input_pending
= 0;
3203 /* So people can tell when we have read the available input. */
3204 input_signal_count
++;
3207 abort (); /* Don't think this happens. */
3210 /* If available, Xlib uses FIOSNBIO to make the socket
3211 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
3212 FIOSNBIO is ignored, and instead of signalling EWOULDBLOCK,
3213 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
3214 fcntl (fileno (stdin
), F_SETFL
, 0);
3215 #endif /* ! defined (FIOSNBIO) */
3219 if (! (fcntl (fileno (stdin
), F_GETFL
, 0) & O_NDELAY
))
3221 extern int read_alarm_should_throw
;
3222 read_alarm_should_throw
= 1;
3223 XPeekEvent (XDISPLAY
&event
);
3224 read_alarm_should_throw
= 0;
3226 #endif /* HAVE_SELECT */
3229 while (XStuffPending () != 0)
3231 XNextEvent (XDISPLAY
&event
);
3238 if (event
.xclient
.message_type
== Xatom_wm_protocols
3239 && event
.xclient
.format
== 32)
3241 if (event
.xclient
.data
.l
[0] == Xatom_wm_take_focus
)
3243 f
= x_window_to_frame (event
.xclient
.window
);
3244 /* Since we set WM_TAKE_FOCUS, we must call
3245 XSetInputFocus explicitly. But not if f is null,
3246 since that might be an event for a deleted frame. */
3248 XSetInputFocus (event
.xclient
.display
,
3249 event
.xclient
.window
,
3250 RevertToPointerRoot
,
3251 event
.xclient
.data
.l
[1]);
3252 /* Not certain about handling scroll bars here */
3254 else if (event
.xclient
.data
.l
[0] == Xatom_wm_save_yourself
)
3256 /* Save state modify the WM_COMMAND property to
3257 something which can reinstate us. This notifies
3258 the session manager, who's looking for such a
3259 PropertyNotify. Can restart processing when
3260 a keyboard or mouse event arrives. */
3263 /* This is just so we only give real data once
3264 for a single Emacs process. */
3265 if (x_top_window_to_frame (event
.xclient
.window
)
3267 XSetCommand (x_current_display
,
3268 event
.xclient
.window
,
3269 initial_argv
, initial_argc
);
3271 XSetCommand (x_current_display
,
3272 event
.xclient
.window
,
3276 else if (event
.xclient
.data
.l
[0] == Xatom_wm_delete_window
)
3278 struct frame
*f
= x_any_window_to_frame (event
.xclient
.window
);
3285 bufp
->kind
= delete_window_event
;
3286 XSETFRAME (bufp
->frame_or_window
, f
);
3294 else if (event
.xclient
.message_type
== Xatom_wm_configure_denied
)
3297 else if (event
.xclient
.message_type
== Xatom_wm_window_moved
)
3300 struct frame
*f
= x_window_to_frame (event
.xclient
.window
);
3302 new_x
= event
.xclient
.data
.s
[0];
3303 new_y
= event
.xclient
.data
.s
[1];
3307 f
->display
.x
->left_pos
= new_x
;
3308 f
->display
.x
->top_pos
= new_y
;
3311 #if defined (USE_X_TOOLKIT) && defined (HAVE_X11R5)
3312 else if (event
.xclient
.message_type
== Xatom_editres_name
)
3314 struct frame
*f
= x_any_window_to_frame (event
.xclient
.window
);
3315 _XEditResCheckMessages (f
->display
.x
->widget
, NULL
, &event
, NULL
);
3317 #endif /* USE_X_TOOLKIT and HAVE_X11R5 */
3321 case SelectionNotify
:
3322 #ifdef USE_X_TOOLKIT
3323 if (! x_window_to_frame (event
.xselection
.requestor
))
3325 #endif /* not USE_X_TOOLKIT */
3326 x_handle_selection_notify (&event
);
3329 case SelectionClear
: /* Someone has grabbed ownership. */
3330 #ifdef USE_X_TOOLKIT
3331 if (! x_window_to_frame (event
.xselectionclear
.window
))
3333 #endif /* USE_X_TOOLKIT */
3335 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
3340 bufp
->kind
= selection_clear_event
;
3341 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3342 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3343 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3351 case SelectionRequest
: /* Someone wants our selection. */
3352 #ifdef USE_X_TOOLKIT
3353 if (!x_window_to_frame (event
.xselectionrequest
.owner
))
3355 #endif /* USE_X_TOOLKIT */
3356 if (x_queue_selection_requests
)
3357 x_queue_event (&event
);
3360 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
3365 bufp
->kind
= selection_request_event
;
3366 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
3367 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
3368 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
3369 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
3370 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
3371 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
3379 case PropertyNotify
:
3380 #ifdef USE_X_TOOLKIT
3381 if (!x_any_window_to_frame (event
.xproperty
.window
))
3383 #endif /* not USE_X_TOOLKIT */
3384 x_handle_property_notify (&event
);
3387 case ReparentNotify
:
3388 f
= x_top_window_to_frame (event
.xreparent
.window
);
3392 f
->display
.x
->parent_desc
= event
.xreparent
.parent
;
3393 x_real_positions (f
, &x
, &y
);
3394 f
->display
.x
->left_pos
= x
;
3395 f
->display
.x
->top_pos
= y
;
3400 f
= x_window_to_frame (event
.xexpose
.window
);
3403 if (f
->async_visible
== 0)
3405 f
->async_visible
= 1;
3406 f
->async_iconified
= 0;
3407 SET_FRAME_GARBAGED (f
);
3410 dumprectangle (x_window_to_frame (event
.xexpose
.window
),
3411 event
.xexpose
.x
, event
.xexpose
.y
,
3412 event
.xexpose
.width
, event
.xexpose
.height
);
3416 struct scroll_bar
*bar
3417 = x_window_to_scroll_bar (event
.xexpose
.window
);
3420 x_scroll_bar_expose (bar
, &event
);
3421 #ifdef USE_X_TOOLKIT
3424 #endif /* USE_X_TOOLKIT */
3428 case GraphicsExpose
: /* This occurs when an XCopyArea's
3429 source area was obscured or not
3431 f
= x_window_to_frame (event
.xgraphicsexpose
.drawable
);
3435 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
3436 event
.xgraphicsexpose
.width
,
3437 event
.xgraphicsexpose
.height
);
3439 #ifdef USE_X_TOOLKIT
3442 #endif /* USE_X_TOOLKIT */
3445 case NoExpose
: /* This occurs when an XCopyArea's
3446 source area was completely
3451 f
= x_any_window_to_frame (event
.xunmap
.window
);
3452 if (f
) /* F may no longer exist if
3453 the frame was deleted. */
3455 /* While a frame is unmapped, display generation is
3456 disabled; you don't want to spend time updating a
3457 display that won't ever be seen. */
3458 f
->async_visible
= 0;
3459 /* We can't distinguish, from the event, whether the window
3460 has become iconified or invisible. So assume, if it
3461 was previously visible, than now it is iconified.
3462 We depend on x_make_frame_invisible to mark it iconified. */
3463 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
3464 f
->async_iconified
= 1;
3466 #ifdef USE_X_TOOLKIT
3468 #endif /* USE_X_TOOLKIT */
3472 /* We use x_top_window_to_frame because map events can come
3473 for subwindows and they don't mean that the frame is visible. */
3474 f
= x_top_window_to_frame (event
.xmap
.window
);
3477 f
->async_visible
= 1;
3478 f
->async_iconified
= 0;
3480 /* wait_reading_process_input will notice this and update
3481 the frame's display structures. */
3482 SET_FRAME_GARBAGED (f
);
3484 #ifdef USE_X_TOOLKIT
3486 #endif /* USE_X_TOOLKIT */
3489 /* Turn off processing if we become fully obscured. */
3490 case VisibilityNotify
:
3494 f
= x_any_window_to_frame (event
.xkey
.window
);
3498 KeySym keysym
, orig_keysym
;
3499 /* al%imercury@uunet.uu.net says that making this 81 instead of
3500 80 fixed a bug whereby meta chars made his Emacs hang. */
3501 unsigned char copy_buffer
[81];
3505 |= x_emacs_to_x_modifiers (extra_keyboard_modifiers
);
3506 modifiers
= event
.xkey
.state
;
3508 /* This will have to go some day... */
3510 /* make_lispy_event turns chars into control chars.
3511 Don't do it here because XLookupString is too eager. */
3512 event
.xkey
.state
&= ~ControlMask
;
3514 XLookupString (&event
.xkey
, copy_buffer
, 80, &keysym
,
3517 orig_keysym
= keysym
;
3521 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
3522 || keysym
== XK_Delete
3523 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
3524 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
3526 /* This recognizes the "extended function keys".
3527 It seems there's no cleaner way.
3528 Test IsModifierKey to avoid handling mode_switch
3530 || ((unsigned) (keysym
) >= XK_Select
3531 && (unsigned)(keysym
) < XK_KP_Space
)
3533 #ifdef XK_dead_circumflex
3534 || orig_keysym
== XK_dead_circumflex
3536 #ifdef XK_dead_grave
3537 || orig_keysym
== XK_dead_grave
3539 #ifdef XK_dead_tilde
3540 || orig_keysym
== XK_dead_tilde
3542 #ifdef XK_dead_diaeresis
3543 || orig_keysym
== XK_dead_diaeresis
3545 #ifdef XK_dead_macron
3546 || orig_keysym
== XK_dead_macron
3548 #ifdef XK_dead_degree
3549 || orig_keysym
== XK_dead_degree
3551 #ifdef XK_dead_acute
3552 || orig_keysym
== XK_dead_acute
3554 #ifdef XK_dead_cedilla
3555 || orig_keysym
== XK_dead_cedilla
3557 #ifdef XK_dead_breve
3558 || orig_keysym
== XK_dead_breve
3560 #ifdef XK_dead_ogonek
3561 || orig_keysym
== XK_dead_ogonek
3563 #ifdef XK_dead_caron
3564 || orig_keysym
== XK_dead_caron
3566 #ifdef XK_dead_doubleacute
3567 || orig_keysym
== XK_dead_doubleacute
3569 #ifdef XK_dead_abovedot
3570 || orig_keysym
== XK_dead_abovedot
3572 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
3573 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
3574 /* Any "vendor-specific" key is ok. */
3575 || (orig_keysym
& (1 << 28)))
3576 && ! (IsModifierKey (orig_keysym
)
3578 #ifdef XK_Mode_switch
3579 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
3582 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
3584 #endif /* not HAVE_X11R5 */
3587 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3589 temp_buffer
[temp_index
++] = keysym
;
3590 bufp
->kind
= non_ascii_keystroke
;
3591 bufp
->code
= keysym
;
3592 XSETFRAME (bufp
->frame_or_window
, f
);
3593 bufp
->modifiers
= x_x_to_emacs_modifiers (modifiers
);
3594 bufp
->timestamp
= event
.xkey
.time
;
3599 else if (numchars
> nbytes
)
3603 for (i
= 0; i
< nbytes
; i
++)
3605 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
3607 temp_buffer
[temp_index
++] = copy_buffer
[i
];
3608 bufp
->kind
= ascii_keystroke
;
3609 bufp
->code
= copy_buffer
[i
];
3610 XSETFRAME (bufp
->frame_or_window
, f
);
3611 bufp
->modifiers
= x_x_to_emacs_modifiers (modifiers
);
3612 bufp
->timestamp
= event
.xkey
.time
;
3627 /* Here's a possible interpretation of the whole
3628 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If you get a
3629 FocusIn event, you have to get a FocusOut event before you
3630 relinquish the focus. If you haven't received a FocusIn event,
3631 then a mere LeaveNotify is enough to free you. */
3634 f
= x_any_window_to_frame (event
.xcrossing
.window
);
3636 if (event
.xcrossing
.focus
) /* Entered Window */
3638 /* Avoid nasty pop/raise loops. */
3639 if (f
&& (!(f
->auto_raise
)
3641 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
3643 x_new_focus_frame (f
);
3644 enter_timestamp
= event
.xcrossing
.time
;
3647 else if (f
== x_focus_frame
)
3648 x_new_focus_frame (0);
3649 /* EnterNotify counts as mouse movement,
3650 so update things that depend on mouse position. */
3652 note_mouse_movement (f
, &event
.xmotion
);
3653 #ifdef USE_X_TOOLKIT
3655 #endif /* USE_X_TOOLKIT */
3659 f
= x_any_window_to_frame (event
.xfocus
.window
);
3660 if (event
.xfocus
.detail
!= NotifyPointer
)
3661 x_focus_event_frame
= f
;
3663 x_new_focus_frame (f
);
3664 #ifdef USE_X_TOOLKIT
3666 #endif /* USE_X_TOOLKIT */
3671 f
= x_top_window_to_frame (event
.xcrossing
.window
);
3674 if (f
== mouse_face_mouse_frame
)
3675 /* If we move outside the frame,
3676 then we're certainly no longer on any text in the frame. */
3677 clear_mouse_face ();
3679 if (event
.xcrossing
.focus
)
3681 if (! x_focus_event_frame
)
3682 x_new_focus_frame (0);
3684 x_new_focus_frame (f
);
3688 if (f
== x_focus_event_frame
)
3689 x_focus_event_frame
= 0;
3690 if (f
== x_focus_frame
)
3691 x_new_focus_frame (0);
3694 #ifdef USE_X_TOOLKIT
3696 #endif /* USE_X_TOOLKIT */
3700 f
= x_any_window_to_frame (event
.xfocus
.window
);
3701 if (event
.xfocus
.detail
!= NotifyPointer
3702 && f
== x_focus_event_frame
)
3703 x_focus_event_frame
= 0;
3704 if (f
&& f
== x_focus_frame
)
3705 x_new_focus_frame (0);
3706 #ifdef USE_X_TOOLKIT
3708 #endif /* USE_X_TOOLKIT */
3713 if (x_mouse_grabbed
&& last_mouse_frame
3714 && FRAME_LIVE_P (last_mouse_frame
))
3715 f
= last_mouse_frame
;
3717 f
= x_window_to_frame (event
.xmotion
.window
);
3719 note_mouse_movement (f
, &event
.xmotion
);
3722 struct scroll_bar
*bar
3723 = x_window_to_scroll_bar (event
.xmotion
.window
);
3726 x_scroll_bar_note_movement (bar
, &event
);
3728 /* If we move outside the frame,
3729 then we're certainly no longer on any text in the frame. */
3730 clear_mouse_face ();
3733 #if 0 /* This should be unnecessary, since the toolkit has no use
3734 for motion events that happen outside of the menu event loop,
3735 and it seems to cause the bug that mouse events stop coming
3737 #ifdef USE_X_TOOLKIT
3739 #endif /* USE_X_TOOLKIT */
3743 case ConfigureNotify
:
3744 f
= x_any_window_to_frame (event
.xconfigure
.window
);
3745 #ifdef USE_X_TOOLKIT
3748 && ! event
.xconfigure
.send_event
3750 && (event
.xconfigure
.window
== XtWindow (f
->display
.x
->widget
)))
3755 /* Find the position of the outside upper-left corner of
3756 the window, in the root coordinate system. Don't
3757 refer to the parent window here; we may be processing
3758 this event after the window manager has changed our
3759 parent, but before we have reached the ReparentNotify. */
3760 XTranslateCoordinates (x_current_display
,
3762 /* From-window, to-window. */
3763 XtWindow (f
->display
.x
->widget
),
3766 /* From-position, to-position. */
3767 -event
.xconfigure
.border_width
,
3768 -event
.xconfigure
.border_width
,
3773 event
.xconfigure
.x
= win_x
;
3774 event
.xconfigure
.y
= win_y
;
3776 f
->display
.x
->pixel_width
= event
.xconfigure
.width
;
3777 f
->display
.x
->pixel_height
= event
.xconfigure
.height
;
3778 f
->display
.x
->left_pos
= event
.xconfigure
.x
;
3779 f
->display
.x
->top_pos
= event
.xconfigure
.y
;
3781 /* What we have now is the position of Emacs's own window.
3782 Convert that to the position of the window manager window. */
3785 x_real_positions (f
, &x
, &y
);
3786 f
->display
.x
->left_pos
= x
;
3787 f
->display
.x
->top_pos
= y
;
3791 #else /* not USE_X_TOOLKIT */
3794 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
3795 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
3797 /* Even if the number of character rows and columns has
3798 not changed, the font size may have changed, so we need
3799 to check the pixel dimensions as well. */
3800 if (columns
!= f
->width
3801 || rows
!= f
->height
3802 || event
.xconfigure
.width
!= f
->display
.x
->pixel_width
3803 || event
.xconfigure
.height
!= f
->display
.x
->pixel_height
)
3805 change_frame_size (f
, rows
, columns
, 0, 1);
3806 SET_FRAME_GARBAGED (f
);
3809 if (! event
.xconfigure
.send_event
)
3814 /* Find the position of the outside upper-left corner of
3815 the window, in the root coordinate system. Don't
3816 refer to the parent window here; we may be processing
3817 this event after the window manager has changed our
3818 parent, but before we have reached the ReparentNotify. */
3819 XTranslateCoordinates (x_current_display
,
3821 /* From-window, to-window. */
3822 f
->display
.x
->window_desc
,
3825 /* From-position, to-position. */
3826 -event
.xconfigure
.border_width
,
3827 -event
.xconfigure
.border_width
,
3832 event
.xconfigure
.x
= win_x
;
3833 event
.xconfigure
.y
= win_y
;
3836 f
->display
.x
->pixel_width
= event
.xconfigure
.width
;
3837 f
->display
.x
->pixel_height
= event
.xconfigure
.height
;
3838 f
->display
.x
->left_pos
= event
.xconfigure
.x
;
3839 f
->display
.x
->top_pos
= event
.xconfigure
.y
;
3841 /* What we have now is the position of Emacs's own window.
3842 Convert that to the position of the window manager window. */
3845 x_real_positions (f
, &x
, &y
);
3846 f
->display
.x
->left_pos
= x
;
3847 f
->display
.x
->top_pos
= y
;
3848 if (y
!= event
.xconfigure
.y
)
3850 /* Since the WM decorations come below top_pos now,
3851 we must put them below top_pos in the future. */
3852 f
->display
.x
->win_gravity
= NorthWestGravity
;
3853 x_wm_set_size_hint (f
, 0, 0);
3857 #endif /* not USE_X_TOOLKIT */
3863 /* If we decide we want to generate an event to be seen
3864 by the rest of Emacs, we put it here. */
3865 struct input_event emacs_event
;
3866 emacs_event
.kind
= no_event
;
3868 bzero (&compose_status
, sizeof (compose_status
));
3870 f
= x_window_to_frame (event
.xbutton
.window
);
3873 if (!x_focus_frame
|| (f
== x_focus_frame
))
3874 construct_mouse_click (&emacs_event
, &event
, f
);
3878 struct scroll_bar
*bar
3879 = x_window_to_scroll_bar (event
.xbutton
.window
);
3882 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
3883 #ifdef USE_X_TOOLKIT
3886 /* Assume we have a menubar button press. A bad
3887 assumption should behave benignly. */
3888 popup_get_selection (&event
);
3891 #endif /* USE_X_TOOLKIT */
3894 if (event
.type
== ButtonPress
)
3896 x_mouse_grabbed
|= (1 << event
.xbutton
.button
);
3897 Vmouse_depressed
= Qt
;
3898 last_mouse_frame
= f
;
3902 x_mouse_grabbed
&= ~(1 << event
.xbutton
.button
);
3903 if (!x_mouse_grabbed
)
3904 Vmouse_depressed
= Qnil
;
3907 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
3909 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
3915 #ifdef USE_X_TOOLKIT
3917 #endif /* USE_X_TOOLKIT */
3921 case CirculateNotify
:
3923 case CirculateRequest
:
3927 /* Someone has changed the keyboard mapping - update the
3929 switch (event
.xmapping
.request
)
3931 case MappingModifier
:
3932 x_find_modifier_meanings ();
3933 /* This is meant to fall through. */
3934 case MappingKeyboard
:
3935 XRefreshKeyboardMapping (&event
.xmapping
);
3937 #ifdef USE_X_TOOLKIT
3939 #endif /* USE_X_TOOLKIT */
3943 #ifdef USE_X_TOOLKIT
3946 XtDispatchEvent (&event
);
3948 #endif /* USE_X_TOOLKIT */
3953 /* On some systems, an X bug causes Emacs to get no more events
3954 when the window is destroyed. Detect that. (1994.) */
3957 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
3958 One XNOOP in 100 loops will make Emacs terminate.
3959 B. Bretthauer, 1994 */
3961 if (x_noop_count
>= 100)
3964 XNoOp (x_current_display
);
3968 #if 0 /* This fails for serial-line connections to the X server,
3969 because the characters arrive one by one, and a partial
3970 command makes select return but gives nothing to read.
3971 We'll have to hope that the bug that this tried to fix
3972 in 1988 has been fixed in Xlib or the X server. */
3974 if (expected
&& ! event_found
)
3976 /* AOJ 880406: if select returns true but XPending doesn't, it means that
3977 there is an EOF condition; in other words, that X has died.
3978 Act as if there had been a hangup. */
3979 int fd
= ConnectionNumber (x_current_display
);
3980 SELECT_TYPE mask
, junk1
, junk2
;
3985 EMACS_SET_SECS_USECS (timeout
, 0, 0);
3988 if (0 != select (fd
+ 1, &mask
, &junk1
, &junk2
, &timeout
)
3989 && !XStuffPending ())
3990 kill (getpid (), SIGHUP
);
3992 #endif /* HAVE_SELECT */
3995 /* If the focus was just given to an autoraising frame,
3997 if (pending_autoraise_frame
)
3999 x_raise_frame (pending_autoraise_frame
);
4000 pending_autoraise_frame
= 0;
4007 /* Drawing the cursor. */
4010 /* Draw a hollow box cursor. Don't change the inside of the box. */
4016 int left
= CHAR_TO_PIXEL_COL (f
, curs_x
);
4017 int top
= CHAR_TO_PIXEL_ROW (f
, curs_y
);
4018 int width
= FONT_WIDTH (f
->display
.x
->font
);
4019 int height
= f
->display
.x
->line_height
;
4021 XDrawRectangle (x_current_display
, FRAME_X_WINDOW (f
),
4022 f
->display
.x
->cursor_gc
,
4023 left
, top
, width
- 1, height
- 1);
4026 /* Clear the cursor of frame F to background color,
4027 and mark the cursor as not shown.
4028 This is used when the text where the cursor is
4029 is about to be rewritten. */
4037 if (! FRAME_VISIBLE_P (f
)
4038 || f
->phys_cursor_x
< 0)
4041 x_display_cursor (f
, 0);
4042 f
->phys_cursor_x
= -1;
4045 /* Redraw the glyph at ROW, COLUMN on frame F, in the style
4046 HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
4050 x_draw_single_glyph (f
, row
, column
, glyph
, highlight
)
4057 CHAR_TO_PIXEL_COL (f
, column
),
4058 CHAR_TO_PIXEL_ROW (f
, row
),
4059 &glyph
, 1, highlight
, 0);
4063 x_display_bar_cursor (f
, on
)
4067 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4069 /* This is pointless on invisible frames, and dangerous on garbaged
4070 frames; in the latter case, the frame may be in the midst of
4071 changing its size, and curs_x and curs_y may be off the frame. */
4072 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4075 if (! on
&& f
->phys_cursor_x
< 0)
4078 /* If we're not updating, then we want to use the current frame's
4079 cursor position, not our local idea of where the cursor ought to be. */
4080 if (f
!= updating_frame
)
4082 curs_x
= FRAME_CURSOR_X (f
);
4083 curs_y
= FRAME_CURSOR_Y (f
);
4086 /* If there is anything wrong with the current cursor state, remove it. */
4087 if (f
->phys_cursor_x
>= 0
4089 || f
->phys_cursor_x
!= curs_x
4090 || f
->phys_cursor_y
!= curs_y
4091 || f
->display
.x
->current_cursor
!= bar_cursor
))
4093 /* Erase the cursor by redrawing the character underneath it. */
4094 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4095 f
->phys_cursor_glyph
,
4096 current_glyphs
->highlight
[f
->phys_cursor_y
]);
4097 f
->phys_cursor_x
= -1;
4100 /* If we now need a cursor in the new place or in the new form, do it so. */
4102 && (f
->phys_cursor_x
< 0
4103 || (f
->display
.x
->current_cursor
!= bar_cursor
)))
4105 f
->phys_cursor_glyph
4106 = ((current_glyphs
->enable
[curs_y
]
4107 && curs_x
< current_glyphs
->used
[curs_y
])
4108 ? current_glyphs
->glyphs
[curs_y
][curs_x
]
4110 XFillRectangle (x_current_display
, FRAME_X_WINDOW (f
),
4111 f
->display
.x
->cursor_gc
,
4112 CHAR_TO_PIXEL_COL (f
, curs_x
),
4113 CHAR_TO_PIXEL_ROW (f
, curs_y
),
4114 1, f
->display
.x
->line_height
);
4116 f
->phys_cursor_x
= curs_x
;
4117 f
->phys_cursor_y
= curs_y
;
4119 f
->display
.x
->current_cursor
= bar_cursor
;
4122 if (updating_frame
!= f
)
4127 /* Turn the displayed cursor of frame F on or off according to ON.
4128 If ON is nonzero, where to put the cursor is specified
4129 by F->cursor_x and F->cursor_y. */
4132 x_display_box_cursor (f
, on
)
4136 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
4138 /* This is pointless on invisible frames, and dangerous on garbaged
4139 frames; in the latter case, the frame may be in the midst of
4140 changing its size, and curs_x and curs_y may be off the frame. */
4141 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
4144 /* If cursor is off and we want it off, return quickly. */
4145 if (!on
&& f
->phys_cursor_x
< 0)
4148 /* If we're not updating, then we want to use the current frame's
4149 cursor position, not our local idea of where the cursor ought to be. */
4150 if (f
!= updating_frame
)
4152 curs_x
= FRAME_CURSOR_X (f
);
4153 curs_y
= FRAME_CURSOR_Y (f
);
4156 /* If cursor is currently being shown and we don't want it to be
4157 or it is in the wrong place,
4158 or we want a hollow box and it's not so, (pout!)
4160 if (f
->phys_cursor_x
>= 0
4162 || f
->phys_cursor_x
!= curs_x
4163 || f
->phys_cursor_y
!= curs_y
4164 || (f
->display
.x
->current_cursor
!= hollow_box_cursor
4165 && (f
!= x_highlight_frame
))))
4167 int mouse_face_here
= 0;
4169 /* If the cursor is in the mouse face area, redisplay that when
4170 we clear the cursor. */
4171 if (f
== mouse_face_mouse_frame
4173 (f
->phys_cursor_y
> mouse_face_beg_row
4174 || (f
->phys_cursor_y
== mouse_face_beg_row
4175 && f
->phys_cursor_x
>= mouse_face_beg_col
))
4177 (f
->phys_cursor_y
< mouse_face_end_row
4178 || (f
->phys_cursor_y
== mouse_face_end_row
4179 && f
->phys_cursor_x
< mouse_face_end_col
)))
4180 mouse_face_here
= 1;
4182 /* If the font is not as tall as a whole line,
4183 we must explicitly clear the line's whole height. */
4184 if (FONT_HEIGHT (f
->display
.x
->font
) != f
->display
.x
->line_height
)
4185 XClearArea (x_current_display
, FRAME_X_WINDOW (f
),
4186 CHAR_TO_PIXEL_COL (f
, f
->phys_cursor_x
),
4187 CHAR_TO_PIXEL_ROW (f
, f
->phys_cursor_y
),
4188 FONT_WIDTH (f
->display
.x
->font
),
4189 f
->display
.x
->line_height
, False
);
4190 /* Erase the cursor by redrawing the character underneath it. */
4191 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
4192 f
->phys_cursor_glyph
,
4195 : current_glyphs
->highlight
[f
->phys_cursor_y
]));
4196 f
->phys_cursor_x
= -1;
4199 /* If we want to show a cursor,
4200 or we want a box cursor and it's not so,
4201 write it in the right place. */
4203 && (f
->phys_cursor_x
< 0
4204 || (f
->display
.x
->current_cursor
!= filled_box_cursor
4205 && f
== x_highlight_frame
)))
4207 f
->phys_cursor_glyph
4208 = ((current_glyphs
->enable
[curs_y
]
4209 && curs_x
< current_glyphs
->used
[curs_y
])
4210 ? current_glyphs
->glyphs
[curs_y
][curs_x
]
4212 if (f
!= x_highlight_frame
)
4215 f
->display
.x
->current_cursor
= hollow_box_cursor
;
4219 x_draw_single_glyph (f
, curs_y
, curs_x
,
4220 f
->phys_cursor_glyph
, 2);
4221 f
->display
.x
->current_cursor
= filled_box_cursor
;
4224 f
->phys_cursor_x
= curs_x
;
4225 f
->phys_cursor_y
= curs_y
;
4228 if (updating_frame
!= f
)
4232 x_display_cursor (f
, on
)
4238 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
4239 x_display_box_cursor (f
, on
);
4240 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
4241 x_display_bar_cursor (f
, on
);
4243 /* Those are the only two we have implemented! */
4251 /* Refresh bitmap kitchen sink icon for frame F
4252 when we get an expose event for it. */
4257 /* Normally, the window manager handles this function. */
4260 /* Make the x-window of frame F use the gnu icon bitmap. */
4266 int mask
, bitmap_id
;
4269 if (FRAME_X_WINDOW (f
) == 0)
4274 bitmap_id
= x_create_bitmap_from_file (f
, file
);
4278 icon_bitmap
= x_create_bitmap_from_data (f
, gnu_bits
,
4279 gnu_width
, gnu_height
);
4280 x_reference_bitmap (icon_bitmap
);
4281 bitmap_id
= icon_bitmap
;
4284 x_wm_set_icon_pixmap (f
, bitmap_id
);
4285 f
->display
.x
->icon_bitmap
= bitmap_id
;
4291 /* Make the x-window of frame F use a rectangle with text. */
4294 x_text_icon (f
, icon_name
)
4298 if (FRAME_X_WINDOW (f
) == 0)
4302 f
->display
.x
->icon_label
= icon_name
;
4304 if (! f
->display
.x
->icon_label
)
4305 f
->display
.x
->icon_label
= " *emacs* ";
4308 XSetIconName (x_current_display
, FRAME_X_WINDOW (f
),
4309 (char *) f
->display
.x
->icon_label
);
4312 x_destroy_bitmap (f
->display
.x
->icon_bitmap
);
4313 f
->display
.x
->icon_bitmap
= 0;
4314 x_wm_set_icon_pixmap (f
, 0);
4319 /* Handling X errors. */
4321 /* Shut down Emacs in an orderly fashion, because of a SIGPIPE on the
4322 X server's connection, or an error reported via the X protocol. */
4325 x_connection_closed ()
4330 shut_down_emacs (0, 1, Qnil
);
4335 /* An X error handler which prints an error message and then kills
4336 Emacs. This is what's normally installed as Xlib's handler for
4339 x_error_quitter (display
, error
)
4345 /* Note that there is no real way portable across R3/R4 to get the
4346 original error handler. */
4348 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
4349 fprintf (stderr
, "X protocol error: %s on protocol request %d\n",
4350 buf
, error
->request_code
);
4353 /* While we're testing Emacs 19, we'll just dump core whenever we
4354 get an X error, so we can figure out why it happened. */
4358 x_connection_closed ();
4361 /* A handler for X IO errors which prints an error message and then
4362 kills Emacs. This is what is always installed as Xlib's handler
4365 x_io_error_quitter (display
)
4368 fprintf (stderr
, "Connection to X server %s lost.\n",
4369 XDisplayName (DisplayString (display
)));
4372 /* While we're testing Emacs 19, we'll just dump core whenever we
4373 get an X error, so we can figure out why it happened. */
4377 x_connection_closed ();
4380 /* A buffer for storing X error messages. */
4381 static char *x_caught_error_message
;
4382 #define X_CAUGHT_ERROR_MESSAGE_SIZE 200
4384 /* An X error handler which stores the error message in
4385 x_caught_error_message. This is what's installed when
4386 x_catch_errors is in effect. */
4388 x_error_catcher (display
, error
)
4392 XGetErrorText (display
, error
->error_code
,
4393 x_caught_error_message
, X_CAUGHT_ERROR_MESSAGE_SIZE
);
4397 /* Begin trapping X errors.
4399 After calling this function, X protocol errors no longer cause
4400 Emacs to exit; instead, they are recorded in x_cfc_error_message.
4402 Calling x_check_errors signals an Emacs error if an X error has
4403 occurred since the last call to x_catch_errors or x_check_errors.
4405 Calling x_uncatch_errors resumes the normal error handling. */
4407 void x_catch_errors (), x_check_errors (), x_uncatch_errors ();
4412 /* Make sure any errors from previous requests have been dealt with. */
4413 XSync (x_current_display
, False
);
4415 /* Set up the error buffer. */
4416 x_caught_error_message
4417 = (char*) xmalloc (X_CAUGHT_ERROR_MESSAGE_SIZE
);
4418 x_caught_error_message
[0] = '\0';
4420 /* Install our little error handler. */
4421 XHandleError (x_error_catcher
);
4424 /* If any X protocol errors have arrived since the last call to
4425 x_catch_errors or x_check_errors, signal an Emacs error using
4426 sprintf (a buffer, FORMAT, the x error message text) as the text. */
4429 x_check_errors (format
)
4432 /* Make sure to catch any errors incurred so far. */
4433 XSync (x_current_display
, False
);
4435 if (x_caught_error_message
[0])
4437 char buf
[X_CAUGHT_ERROR_MESSAGE_SIZE
+ 56];
4439 sprintf (buf
, format
, x_caught_error_message
);
4440 x_uncatch_errors ();
4445 /* Nonzero if we had any X protocol errors since we did x_catch_errors. */
4450 /* Make sure to catch any errors incurred so far. */
4451 XSync (x_current_display
, False
);
4453 return x_caught_error_message
[0] != 0;
4456 /* Stop catching X protocol errors and let them make Emacs die. */
4461 xfree (x_caught_error_message
);
4462 x_caught_error_message
= 0;
4463 XHandleError (x_error_quitter
);
4467 static unsigned int x_wire_count
;
4470 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
4475 /* Changing the font of the frame. */
4477 /* Set the font of the x-window specified by frame F
4478 to the font named NEWNAME. This is safe to use
4479 even before F has an actual x-window. */
4488 /* A table of all the fonts we have already loaded. */
4489 static struct font_info
*x_font_table
;
4491 /* The current capacity of x_font_table. */
4492 static int x_font_table_size
;
4494 /* The number of fonts actually stored in x_font_table.
4495 x_font_table[n] is used and valid iff 0 <= n < n_fonts.
4496 0 <= n_fonts <= x_font_table_size. */
4499 /* Give frame F the font named FONTNAME as its default font, and
4500 return the full name of that font. FONTNAME may be a wildcard
4501 pattern; in that case, we choose some font that fits the pattern.
4502 The return value shows which font we chose. */
4505 x_new_font (f
, fontname
)
4507 register char *fontname
;
4510 int n_matching_fonts
;
4511 XFontStruct
*font_info
;
4514 /* Get a list of all the fonts that match this name. Once we
4515 have a list of matching fonts, we compare them against the fonts
4516 we already have by comparing font ids. */
4517 font_names
= (char **) XListFonts (x_current_display
, fontname
,
4518 1024, &n_matching_fonts
);
4519 /* Apparently it doesn't set n_matching_fonts to zero when it can't
4520 find any matches; font_names == 0 is the only clue. */
4522 n_matching_fonts
= 0;
4524 /* Don't just give up if n_matching_fonts is 0.
4525 Apparently there's a bug on Suns: XListFontsWithInfo can
4526 fail to find a font, but XLoadQueryFont may still find it. */
4528 /* See if we've already loaded a matching font. */
4529 already_loaded
= -1;
4530 if (n_matching_fonts
!= 0)
4534 for (i
= 0; i
< n_fonts
; i
++)
4535 for (j
= 0; j
< n_matching_fonts
; j
++)
4536 if (!strcmp (x_font_table
[i
].name
, font_names
[j
])
4537 || !strcmp (x_font_table
[i
].full_name
, font_names
[j
]))
4540 fontname
= x_font_table
[i
].full_name
;
4546 /* If we have, just return it from the table. */
4547 if (already_loaded
>= 0)
4548 f
->display
.x
->font
= x_font_table
[already_loaded
].font
;
4549 /* Otherwise, load the font and add it to the table. */
4556 /* Try to find a character-cell font in the list. */
4558 /* A laudable goal, but this isn't how to do it. */
4559 for (i
= 0; i
< n_matching_fonts
; i
++)
4560 if (! font_info
[i
].per_char
)
4566 /* See comment above. */
4567 if (n_matching_fonts
!= 0)
4568 fontname
= font_names
[i
];
4570 font
= (XFontStruct
*) XLoadQueryFont (x_current_display
, fontname
);
4573 /* Free the information from XListFonts. */
4574 if (n_matching_fonts
)
4575 XFreeFontNames (font_names
);
4579 /* Do we need to create the table? */
4580 if (x_font_table_size
== 0)
4582 x_font_table_size
= 16;
4584 = (struct font_info
*) xmalloc (x_font_table_size
4585 * sizeof (x_font_table
[0]));
4587 /* Do we need to grow the table? */
4588 else if (n_fonts
>= x_font_table_size
)
4590 x_font_table_size
*= 2;
4592 = (struct font_info
*) xrealloc (x_font_table
,
4594 * sizeof (x_font_table
[0])));
4597 /* Try to get the full name of FONT. Put it in full_name. */
4599 for (i
= 0; i
< font
->n_properties
; i
++)
4602 = XGetAtomName (x_current_display
, font
->properties
[i
].name
);
4603 if (!strcmp (atom
, "FONT"))
4605 char *name
= XGetAtomName (x_current_display
,
4606 (Atom
) (font
->properties
[i
].card32
));
4610 /* Count the number of dashes in the "full name".
4611 If it is too few, this isn't really the font's full name,
4613 In X11R4, the fonts did not come with their canonical names
4631 x_font_table
[n_fonts
].name
= (char *) xmalloc (strlen (fontname
) + 1);
4632 bcopy (fontname
, x_font_table
[n_fonts
].name
, strlen (fontname
) + 1);
4634 x_font_table
[n_fonts
].full_name
= full_name
;
4636 x_font_table
[n_fonts
].full_name
= x_font_table
[n_fonts
].name
;
4637 f
->display
.x
->font
= x_font_table
[n_fonts
++].font
= font
;
4640 fontname
= full_name
;
4643 /* Compute the scroll bar width in character columns. */
4644 if (f
->scroll_bar_pixel_width
> 0)
4646 int wid
= FONT_WIDTH (f
->display
.x
->font
);
4647 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
4650 f
->scroll_bar_cols
= 2;
4652 /* Now make the frame display the given font. */
4653 if (FRAME_X_WINDOW (f
) != 0)
4655 XSetFont (x_current_display
, f
->display
.x
->normal_gc
,
4656 f
->display
.x
->font
->fid
);
4657 XSetFont (x_current_display
, f
->display
.x
->reverse_gc
,
4658 f
->display
.x
->font
->fid
);
4659 XSetFont (x_current_display
, f
->display
.x
->cursor_gc
,
4660 f
->display
.x
->font
->fid
);
4662 frame_update_line_height (f
);
4663 x_set_window_size (f
, 0, f
->width
, f
->height
);
4666 /* If we are setting a new frame's font for the first time,
4667 there are no faces yet, so this font's height is the line height. */
4668 f
->display
.x
->line_height
= FONT_HEIGHT (f
->display
.x
->font
);
4671 Lisp_Object lispy_name
;
4673 lispy_name
= build_string (fontname
);
4675 /* Free the information from XListFonts. The data
4676 we actually retain comes from XLoadQueryFont. */
4677 XFreeFontNames (font_names
);
4683 x_calc_absolute_position (f
)
4687 int win_x
= 0, win_y
= 0;
4688 int flags
= f
->display
.x
->size_hint_flags
;
4690 /* Find the position of the outside upper-left corner of
4691 the inner window, with respect to the outer window. */
4692 if (f
->display
.x
->parent_desc
!= ROOT_WINDOW
)
4695 XTranslateCoordinates (x_current_display
,
4697 /* From-window, to-window. */
4698 f
->display
.x
->window_desc
,
4699 f
->display
.x
->parent_desc
,
4701 /* From-position, to-position. */
4702 0, 0, &win_x
, &win_y
,
4709 /* Treat negative positions as relative to the leftmost bottommost
4710 position that fits on the screen. */
4711 if (flags
& XNegative
)
4712 f
->display
.x
->left_pos
= (x_screen_width
4713 - 2 * f
->display
.x
->border_width
- win_x
4715 + f
->display
.x
->left_pos
);
4717 if (flags
& YNegative
)
4718 f
->display
.x
->top_pos
= (x_screen_height
4719 - 2 * f
->display
.x
->border_width
- win_y
4721 + f
->display
.x
->top_pos
);
4722 /* The left_pos and top_pos
4723 are now relative to the top and left screen edges,
4724 so the flags should correspond. */
4725 f
->display
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
4728 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
4729 to really change the position, and 0 when calling from
4730 x_make_frame_visible (in that case, XOFF and YOFF are the current
4731 position values). */
4733 x_set_offset (f
, xoff
, yoff
, change_gravity
)
4735 register int xoff
, yoff
;
4740 f
->display
.x
->top_pos
= yoff
;
4741 f
->display
.x
->left_pos
= xoff
;
4742 f
->display
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
4744 f
->display
.x
->size_hint_flags
|= XNegative
;
4746 f
->display
.x
->size_hint_flags
|= YNegative
;
4747 f
->display
.x
->win_gravity
= NorthWestGravity
;
4749 x_calc_absolute_position (f
);
4752 x_wm_set_size_hint (f
, 0, 0);
4754 #ifdef USE_X_TOOLKIT
4755 XMoveWindow (XDISPLAY
XtWindow (f
->display
.x
->widget
),
4756 f
->display
.x
->left_pos
, f
->display
.x
->top_pos
);
4757 #else /* not USE_X_TOOLKIT */
4758 XMoveWindow (XDISPLAY
FRAME_X_WINDOW (f
),
4759 f
->display
.x
->left_pos
, f
->display
.x
->top_pos
);
4760 #endif /* not USE_X_TOOLKIT */
4764 /* Call this to change the size of frame F's x-window.
4765 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
4766 for this size change and subsequent size changes.
4767 Otherwise we leave the window gravity unchanged. */
4769 x_set_window_size (f
, change_gravity
, cols
, rows
)
4774 int pixelwidth
, pixelheight
;
4777 #ifdef USE_X_TOOLKIT
4780 /* The x and y position of the widget is clobbered by the
4781 call to XtSetValues within EmacsFrameSetCharSize.
4782 This is a real kludge, but I don't understand Xt so I can't
4783 figure out a correct fix. Can anyone else tell me? -- rms. */
4784 int xpos
= f
->display
.x
->widget
->core
.x
;
4785 int ypos
= f
->display
.x
->widget
->core
.y
;
4786 EmacsFrameSetCharSize (f
->display
.x
->edit_widget
, cols
, rows
);
4787 f
->display
.x
->widget
->core
.x
= xpos
;
4788 f
->display
.x
->widget
->core
.y
= ypos
;
4792 #else /* not USE_X_TOOLKIT */
4796 check_frame_size (f
, &rows
, &cols
);
4797 f
->display
.x
->vertical_scroll_bar_extra
4798 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4800 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
4801 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
4802 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->display
.x
->font
)));
4803 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
4804 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
4806 f
->display
.x
->win_gravity
= NorthWestGravity
;
4807 x_wm_set_size_hint (f
, 0, 0);
4809 XSync (x_current_display
, False
);
4810 XChangeWindowSize (FRAME_X_WINDOW (f
), pixelwidth
, pixelheight
);
4812 /* Now, strictly speaking, we can't be sure that this is accurate,
4813 but the window manager will get around to dealing with the size
4814 change request eventually, and we'll hear how it went when the
4815 ConfigureNotify event gets here.
4817 We could just not bother storing any of this information here,
4818 and let the ConfigureNotify event set everything up, but that
4819 might be kind of confusing to the lisp code, since size changes
4820 wouldn't be reported in the frame parameters until some random
4821 point in the future when the ConfigureNotify event arrives. */
4822 change_frame_size (f
, rows
, cols
, 0, 0);
4823 PIXEL_WIDTH (f
) = pixelwidth
;
4824 PIXEL_HEIGHT (f
) = pixelheight
;
4826 /* If cursor was outside the new size, mark it as off. */
4827 if (f
->phys_cursor_y
>= rows
4828 || f
->phys_cursor_x
>= cols
)
4830 f
->phys_cursor_x
= -1;
4831 f
->phys_cursor_y
= -1;
4834 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
4835 receive in the ConfigureNotify event; if we get what we asked
4836 for, then the event won't cause the screen to become garbaged, so
4837 we have to make sure to do it here. */
4838 SET_FRAME_GARBAGED (f
);
4842 #endif /* not USE_X_TOOLKIT */
4845 /* Mouse warping, focus shifting, raising and lowering. */
4848 x_set_mouse_position (f
, x
, y
)
4854 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->display
.x
->font
) / 2;
4855 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->display
.x
->line_height
/ 2;
4857 if (pix_x
< 0) pix_x
= 0;
4858 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
4860 if (pix_y
< 0) pix_y
= 0;
4861 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
4865 XWarpMousePointer (FRAME_X_WINDOW (f
), pix_x
, pix_y
);
4869 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
4872 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
4878 XWarpMousePointer (FRAME_X_WINDOW (f
), pix_x
, pix_y
);
4882 x_focus_on_frame (f
)
4885 #if 0 /* This proves to be unpleasant. */
4889 /* I don't think that the ICCCM allows programs to do things like this
4890 without the interaction of the window manager. Whatever you end up
4891 doing with this code, do it to x_unfocus_frame too. */
4892 XSetInputFocus (x_current_display
, FRAME_X_WINDOW (f
),
4893 RevertToPointerRoot
, CurrentTime
);
4901 /* Look at the remarks in x_focus_on_frame. */
4902 if (x_focus_frame
== f
)
4903 XSetInputFocus (x_current_display
, PointerRoot
,
4904 RevertToPointerRoot
, CurrentTime
);
4908 /* Raise frame F. */
4913 if (f
->async_visible
)
4916 #ifdef USE_X_TOOLKIT
4917 XRaiseWindow (XDISPLAY
XtWindow (f
->display
.x
->widget
));
4918 #else /* not USE_X_TOOLKIT */
4919 XRaiseWindow (XDISPLAY
FRAME_X_WINDOW (f
));
4920 #endif /* not USE_X_TOOLKIT */
4926 /* Lower frame F. */
4931 if (f
->async_visible
)
4934 #ifdef USE_X_TOOLKIT
4935 XLowerWindow (XDISPLAY
XtWindow (f
->display
.x
->widget
));
4936 #else /* not USE_X_TOOLKIT */
4937 XLowerWindow (XDISPLAY
FRAME_X_WINDOW (f
));
4938 #endif /* not USE_X_TOOLKIT */
4945 XTframe_raise_lower (f
, raise
)
4955 /* Change from withdrawn state to mapped state,
4958 x_make_frame_visible (f
)
4965 if (x_icon_type (f
))
4968 if (! FRAME_VISIBLE_P (f
))
4970 #ifndef USE_X_TOOLKIT
4971 if (! FRAME_ICONIFIED_P (f
))
4972 x_set_offset (f
, f
->display
.x
->left_pos
, f
->display
.x
->top_pos
, 0);
4975 if (! EQ (Vx_no_window_manager
, Qt
))
4976 x_wm_set_window_state (f
, NormalState
);
4977 #ifdef USE_X_TOOLKIT
4978 /* This was XtPopup, but that did nothing for an iconified frame. */
4979 XtMapWidget (f
->display
.x
->widget
);
4980 #else /* not USE_X_TOOLKIT */
4981 XMapWindow (XDISPLAY
FRAME_X_WINDOW (f
));
4982 #endif /* not USE_X_TOOLKIT */
4983 #if 0 /* This seems to bring back scroll bars in the wrong places
4984 if the window configuration has changed. They seem
4985 to come back ok without this. */
4986 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4987 XMapSubwindows (x_current_display
, FRAME_X_WINDOW (f
));
4993 /* Synchronize to ensure Emacs knows the frame is visible
4994 before we do anything else. We do this loop with input not blocked
4995 so that incoming events are handled. */
4998 int count
= input_signal_count
;
5000 /* This must come after we set COUNT. */
5003 XSETFRAME (frame
, f
);
5008 /* Once we have handled input events,
5009 we should have received the MapNotify if one is coming.
5010 So if we have not got it yet, stop looping.
5011 Some window managers make their own decisions
5012 about visibility. */
5013 if (input_signal_count
!= count
)
5015 /* Machines that do polling rather than SIGIO have been observed
5016 to go into a busy-wait here. So we'll fake an alarm signal
5017 to let the handler know that there's something to be read.
5018 We used to raise a real alarm, but it seems that the handler
5019 isn't always enabled here. This is probably a bug. */
5020 if (input_polling_used ())
5022 /* It could be confusing if a real alarm arrives while processing
5023 the fake one. Turn it off and let the handler reset it. */
5025 input_poll_signal ();
5027 /* Once we have handled input events,
5028 we should have received the MapNotify if one is coming.
5029 So if we have not got it yet, stop looping.
5030 Some window managers make their own decisions
5031 about visibility. */
5032 if (input_signal_count
!= count
)
5035 FRAME_SAMPLE_VISIBILITY (f
);
5039 /* Change from mapped state to withdrawn state. */
5041 x_make_frame_invisible (f
)
5047 #ifdef USE_X_TOOLKIT
5048 /* Use the frame's outermost window, not the one we normally draw on. */
5049 window
= XtWindow (f
->display
.x
->widget
);
5050 #else /* not USE_X_TOOLKIT */
5051 window
= FRAME_X_WINDOW (f
);
5052 #endif /* not USE_X_TOOLKIT */
5054 /* Don't keep the highlight on an invisible frame. */
5055 if (x_highlight_frame
== f
)
5056 x_highlight_frame
= 0;
5058 #if 0/* This might add unreliability; I don't trust it -- rms. */
5059 if (! f
->async_visible
&& ! f
->async_iconified
)
5065 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
5066 that the current position of the window is user-specified, rather than
5067 program-specified, so that when the window is mapped again, it will be
5068 placed at the same location, without forcing the user to position it
5069 by hand again (they have already done that once for this window.) */
5070 x_wm_set_size_hint (f
, 0, 1);
5074 if (! XWithdrawWindow (x_current_display
, window
,
5075 DefaultScreen (x_current_display
)))
5077 UNBLOCK_INPUT_RESIGNAL
;
5078 error ("Can't notify window manager of window withdrawal");
5080 #else /* ! defined (HAVE_X11R4) */
5082 /* Tell the window manager what we're going to do. */
5083 if (! EQ (Vx_no_window_manager
, Qt
))
5087 unmap
.xunmap
.type
= UnmapNotify
;
5088 unmap
.xunmap
.window
= window
;
5089 unmap
.xunmap
.event
= DefaultRootWindow (x_current_display
);
5090 unmap
.xunmap
.from_configure
= False
;
5091 if (! XSendEvent (x_current_display
,
5092 DefaultRootWindow (x_current_display
),
5094 SubstructureRedirectMask
|SubstructureNotifyMask
,
5097 UNBLOCK_INPUT_RESIGNAL
;
5098 error ("Can't notify window manager of withdrawal");
5102 /* Unmap the window ourselves. Cheeky! */
5103 XUnmapWindow (x_current_display
, window
);
5104 #endif /* ! defined (HAVE_X11R4) */
5106 /* We can't distinguish this from iconification
5107 just by the event that we get from the server.
5108 So we can't win using the usual strategy of letting
5109 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5110 and synchronize with the server to make sure we agree. */
5112 FRAME_ICONIFIED_P (f
) = 0;
5113 f
->async_visible
= 0;
5114 f
->async_iconified
= 0;
5121 /* Change window state from mapped to iconified. */
5129 /* Don't keep the highlight on an invisible frame. */
5130 if (x_highlight_frame
== f
)
5131 x_highlight_frame
= 0;
5133 if (f
->async_iconified
)
5138 if (x_icon_type (f
))
5141 #ifdef USE_X_TOOLKIT
5143 if (! FRAME_VISIBLE_P (f
))
5145 if (! EQ (Vx_no_window_manager
, Qt
))
5146 x_wm_set_window_state (f
, IconicState
);
5147 /* This was XtPopup, but that did nothing for an iconified frame. */
5148 XtMapWidget (f
->display
.x
->widget
);
5153 result
= XIconifyWindow (x_current_display
,
5154 XtWindow (f
->display
.x
->widget
),
5155 DefaultScreen (x_current_display
));
5159 error ("Can't notify window manager of iconification");
5161 f
->async_iconified
= 1;
5166 #else /* not USE_X_TOOLKIT */
5168 /* Make sure the X server knows where the window should be positioned,
5169 in case the user deiconifies with the window manager. */
5170 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
5171 x_set_offset (f
, f
->display
.x
->left_pos
, f
->display
.x
->top_pos
, 0);
5173 /* Since we don't know which revision of X we're running, we'll use both
5174 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
5176 /* X11R4: send a ClientMessage to the window manager using the
5177 WM_CHANGE_STATE type. */
5181 message
.xclient
.window
= FRAME_X_WINDOW (f
);
5182 message
.xclient
.type
= ClientMessage
;
5183 message
.xclient
.message_type
= Xatom_wm_change_state
;
5184 message
.xclient
.format
= 32;
5185 message
.xclient
.data
.l
[0] = IconicState
;
5187 if (! XSendEvent (x_current_display
,
5188 DefaultRootWindow (x_current_display
),
5190 SubstructureRedirectMask
| SubstructureNotifyMask
,
5193 UNBLOCK_INPUT_RESIGNAL
;
5194 error ("Can't notify window manager of iconification");
5198 /* X11R3: set the initial_state field of the window manager hints to
5200 x_wm_set_window_state (f
, IconicState
);
5202 if (!FRAME_VISIBLE_P (f
))
5204 /* If the frame was withdrawn, before, we must map it. */
5205 XMapWindow (XDISPLAY
FRAME_X_WINDOW (f
));
5206 #if 0 /* We don't have subwindows in the icon. */
5207 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5208 XMapSubwindows (x_current_display
, FRAME_X_WINDOW (f
));
5212 f
->async_iconified
= 1;
5216 #endif /* not USE_X_TOOLKIT */
5219 /* Destroy the X window of frame F. */
5221 x_destroy_window (f
)
5226 if (f
->display
.x
->icon_desc
!= 0)
5227 XDestroyWindow (XDISPLAY f
->display
.x
->icon_desc
);
5228 XDestroyWindow (XDISPLAY f
->display
.x
->window_desc
);
5229 #ifdef USE_X_TOOLKIT
5230 XtDestroyWidget (f
->display
.x
->widget
);
5231 free_frame_menubar (f
);
5232 #endif /* USE_X_TOOLKIT */
5234 free_frame_faces (f
);
5237 FRAME_X_SCREEN (f
)->reference_count
--;
5239 if (FRAME_X_SCREEN (f
)->reference_count
== 0)
5240 free (FRAME_X_SCREEN (f
));
5243 xfree (f
->display
.x
);
5245 if (f
== x_focus_frame
)
5247 if (f
== x_highlight_frame
)
5248 x_highlight_frame
= 0;
5250 if (f
== mouse_face_mouse_frame
)
5252 mouse_face_beg_row
= mouse_face_beg_col
= -1;
5253 mouse_face_end_row
= mouse_face_end_col
= -1;
5254 mouse_face_window
= Qnil
;
5260 /* Setting window manager hints. */
5262 /* Set the normal size hints for the window manager, for frame F.
5263 FLAGS is the flags word to use--or 0 meaning preserve the flags
5264 that the window now has.
5265 If USER_POSITION is nonzero, we set the USPosition
5266 flag (this is useful when FLAGS is 0). */
5268 x_wm_set_size_hint (f
, flags
, user_position
)
5273 XSizeHints size_hints
;
5275 #ifdef USE_X_TOOLKIT
5278 Dimension widget_width
, widget_height
;
5279 Window window
= XtWindow (f
->display
.x
->widget
);
5280 #else /* not USE_X_TOOLKIT */
5281 Window window
= FRAME_X_WINDOW (f
);
5282 #endif /* not USE_X_TOOLKIT */
5284 /* Setting PMaxSize caused various problems. */
5285 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
5287 flexlines
= f
->height
;
5289 size_hints
.x
= f
->display
.x
->left_pos
;
5290 size_hints
.y
= f
->display
.x
->top_pos
;
5292 #ifdef USE_X_TOOLKIT
5293 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
5294 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
5295 XtGetValues (f
->display
.x
->column_widget
, al
, ac
);
5296 size_hints
.height
= widget_height
;
5297 size_hints
.width
= widget_width
;
5298 #else /* not USE_X_TOOLKIT */
5299 size_hints
.height
= PIXEL_HEIGHT (f
);
5300 size_hints
.width
= PIXEL_WIDTH (f
);
5301 #endif /* not USE_X_TOOLKIT */
5303 size_hints
.width_inc
= FONT_WIDTH (f
->display
.x
->font
);
5304 size_hints
.height_inc
= f
->display
.x
->line_height
;
5305 size_hints
.max_width
= x_screen_width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
5306 size_hints
.max_height
= x_screen_height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
5309 int base_width
, base_height
;
5310 int min_rows
= 0, min_cols
= 0;
5312 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
5313 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
5315 check_frame_size (f
, &min_rows
, &min_cols
);
5317 /* The window manager uses the base width hints to calculate the
5318 current number of rows and columns in the frame while
5319 resizing; min_width and min_height aren't useful for this
5320 purpose, since they might not give the dimensions for a
5321 zero-row, zero-column frame.
5323 We use the base_width and base_height members if we have
5324 them; otherwise, we set the min_width and min_height members
5325 to the size for a zero x zero frame. */
5328 size_hints
.flags
|= PBaseSize
;
5329 size_hints
.base_width
= base_width
;
5330 size_hints
.base_height
= base_height
;
5331 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
5332 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
5334 size_hints
.min_width
= base_width
;
5335 size_hints
.min_height
= base_height
;
5340 size_hints
.flags
|= flags
;
5343 XSizeHints hints
; /* Sometimes I hate X Windows... */
5344 long supplied_return
;
5348 value
= XGetWMNormalHints (x_current_display
, window
, &hints
,
5351 value
= XGetNormalHints (x_current_display
, window
, &hints
);
5356 if (hints
.flags
& PSize
)
5357 size_hints
.flags
|= PSize
;
5358 if (hints
.flags
& PPosition
)
5359 size_hints
.flags
|= PPosition
;
5360 if (hints
.flags
& USPosition
)
5361 size_hints
.flags
|= USPosition
;
5362 if (hints
.flags
& USSize
)
5363 size_hints
.flags
|= USSize
;
5367 size_hints
.win_gravity
= f
->display
.x
->win_gravity
;
5368 size_hints
.flags
|= PWinGravity
;
5372 size_hints
.flags
&= ~ PPosition
;
5373 size_hints
.flags
|= USPosition
;
5375 #endif /* PWinGravity */
5378 XSetWMNormalHints (x_current_display
, window
, &size_hints
);
5380 XSetNormalHints (x_current_display
, window
, &size_hints
);
5384 /* Used for IconicState or NormalState */
5385 x_wm_set_window_state (f
, state
)
5389 #ifdef USE_X_TOOLKIT
5392 XtSetArg (al
[0], XtNinitialState
, state
);
5393 XtSetValues (f
->display
.x
->widget
, al
, 1);
5394 #else /* not USE_X_TOOLKIT */
5395 Window window
= FRAME_X_WINDOW (f
);
5397 f
->display
.x
->wm_hints
.flags
|= StateHint
;
5398 f
->display
.x
->wm_hints
.initial_state
= state
;
5400 XSetWMHints (x_current_display
, window
, &f
->display
.x
->wm_hints
);
5401 #endif /* not USE_X_TOOLKIT */
5404 x_wm_set_icon_pixmap (f
, pixmap_id
)
5408 #ifdef USE_X_TOOLKIT
5409 Window window
= XtWindow (f
->display
.x
->widget
);
5411 Window window
= FRAME_X_WINDOW (f
);
5416 Pixmap icon_pixmap
= x_lookup_pixmap (pixmap_id
);
5417 f
->display
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
5418 f
->display
.x
->wm_hints
.flags
|= IconPixmapHint
;
5422 f
->display
.x
->wm_hints
.icon_pixmap
= None
;
5423 f
->display
.x
->wm_hints
.flags
&= ~IconPixmapHint
;
5426 XSetWMHints (x_current_display
, window
, &f
->display
.x
->wm_hints
);
5429 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5433 #ifdef USE_X_TOOLKIT
5434 Window window
= XtWindow (f
->display
.x
->widget
);
5436 Window window
= FRAME_X_WINDOW (f
);
5439 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
5440 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
5441 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
5443 XSetWMHints (x_current_display
, window
, &f
->display
.x
->wm_hints
);
5447 /* Initialization. */
5449 #ifdef USE_X_TOOLKIT
5450 static XrmOptionDescRec emacs_options
[] = {
5451 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
5452 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
5454 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
5455 XrmoptionSepArg
, NULL
},
5456 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
5458 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5459 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5460 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
5461 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5462 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
5463 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
5464 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
5466 #endif /* USE_X_TOOLKIT */
5469 x_term_init (display_name
, xrm_option
, resource_name
)
5472 char *resource_name
;
5478 #ifndef F_SETOWN_BUG
5480 extern int old_fcntl_owner
;
5481 #endif /* ! defined (F_SETOWN) */
5482 #endif /* F_SETOWN_BUG */
5486 x_focus_frame
= x_highlight_frame
= 0;
5488 #ifdef USE_X_TOOLKIT
5490 XtSetLanguageProc (NULL
, NULL
, NULL
);
5493 argv
= (char **) XtMalloc (7 * sizeof (char *));
5495 argv
[1] = "-display";
5496 argv
[2] = display_name
;
5498 /* Usually `emacs', but not always. */
5499 argv
[4] = resource_name
;
5503 argv
[argc
++] = "-xrm";
5504 argv
[argc
++] = xrm_option
;
5506 Xt_app_shell
= XtAppInitialize (&Xt_app_con
, "Emacs",
5507 emacs_options
, XtNumber (emacs_options
),
5510 XtFree ((char *)argv
);
5511 x_current_display
= XtDisplay (Xt_app_shell
);
5513 #else /* not USE_X_TOOLKIT */
5515 XSetLocaleModifiers ("");
5517 x_current_display
= XOpenDisplay (display_name
);
5518 #endif /* not USE_X_TOOLKIT */
5519 if (x_current_display
== 0)
5520 fatal ("X server %s not responding.\n\
5521 Check the DISPLAY environment variable or use \"-d\"\n",
5526 XSetAfterFunction (x_current_display
, x_trace_wire
);
5528 x_id_name
= (char *) xmalloc (XSTRING (Vinvocation_name
)->size
5529 + XSTRING (Vsystem_name
)->size
5531 sprintf (x_id_name
, "%s@%s",
5532 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
5535 /* Figure out which modifier bits mean what. */
5536 x_find_modifier_meanings ();
5538 /* Get the scroll bar cursor. */
5539 x_vertical_scroll_bar_cursor
5540 = XCreateFontCursor (x_current_display
, XC_sb_v_double_arrow
);
5543 /* Watch for PropertyNotify events on the root window; we use them
5544 to figure out when to invalidate our cache of the cut buffers. */
5545 x_watch_cut_buffer_cache ();
5548 if (ConnectionNumber (x_current_display
) != 0)
5549 change_keyboard_wait_descriptor (ConnectionNumber (x_current_display
));
5550 change_input_fd (ConnectionNumber (x_current_display
));
5552 #ifndef F_SETOWN_BUG
5554 old_fcntl_owner
= fcntl (ConnectionNumber (x_current_display
), F_GETOWN
, 0);
5555 #ifdef F_SETOWN_SOCK_NEG
5556 /* stdin is a socket here */
5557 fcntl (ConnectionNumber (x_current_display
), F_SETOWN
, -getpid ());
5558 #else /* ! defined (F_SETOWN_SOCK_NEG) */
5559 fcntl (ConnectionNumber (x_current_display
), F_SETOWN
, getpid ());
5560 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
5561 #endif /* ! defined (F_SETOWN) */
5562 #endif /* F_SETOWN_BUG */
5566 #endif /* ! defined (SIGIO) */
5568 expose_all_windows
= 0;
5570 clear_frame_hook
= XTclear_frame
;
5571 clear_end_of_line_hook
= XTclear_end_of_line
;
5572 ins_del_lines_hook
= XTins_del_lines
;
5573 change_line_highlight_hook
= XTchange_line_highlight
;
5574 insert_glyphs_hook
= XTinsert_glyphs
;
5575 write_glyphs_hook
= XTwrite_glyphs
;
5576 delete_glyphs_hook
= XTdelete_glyphs
;
5577 ring_bell_hook
= XTring_bell
;
5578 reset_terminal_modes_hook
= XTreset_terminal_modes
;
5579 set_terminal_modes_hook
= XTset_terminal_modes
;
5580 update_begin_hook
= XTupdate_begin
;
5581 update_end_hook
= XTupdate_end
;
5582 set_terminal_window_hook
= XTset_terminal_window
;
5583 read_socket_hook
= XTread_socket
;
5584 frame_up_to_date_hook
= XTframe_up_to_date
;
5585 cursor_to_hook
= XTcursor_to
;
5586 reassert_line_highlight_hook
= XTreassert_line_highlight
;
5587 mouse_position_hook
= XTmouse_position
;
5588 frame_rehighlight_hook
= XTframe_rehighlight
;
5589 frame_raise_lower_hook
= XTframe_raise_lower
;
5590 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
5591 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
5592 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
5593 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
5595 scroll_region_ok
= 1; /* we'll scroll partial frames */
5596 char_ins_del_ok
= 0; /* just as fast to write the line */
5597 line_ins_del_ok
= 1; /* we'll just blt 'em */
5598 fast_clear_end_of_line
= 1; /* X does this well */
5599 memory_below_frame
= 0; /* we don't remember what scrolls
5603 /* Try to use interrupt input; if we can't, then start polling. */
5604 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
5606 /* Note that there is no real way portable across R3/R4 to get the
5607 original error handler. */
5608 XHandleError (x_error_quitter
);
5609 XHandleIOError (x_io_error_quitter
);
5611 /* Disable Window Change signals; they are handled by X events. */
5613 signal (SIGWINCH
, SIG_DFL
);
5614 #endif /* ! defined (SIGWINCH) */
5616 signal (SIGPIPE
, x_connection_closed
);
5622 staticpro (&last_mouse_scroll_bar
);
5623 last_mouse_scroll_bar
= Qnil
;
5624 staticpro (&mouse_face_window
);
5625 mouse_face_window
= Qnil
;
5627 #endif /* ! defined (HAVE_X_WINDOWS) */