1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 1993 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. */
22 Kludge: dup2 is used to put the X-connection socket into desc # 0
23 so that wait_reading_process_input will wait for it in place of
24 actual terminal input.
28 #define NEW_SELECTIONS
30 /* On 4.3 these lose if they come after xterm.h. */
31 /* On HP-UX 8.0 signal.h loses if it comes after config.h. */
32 /* Putting these at the beginning seems to be standard for other .c files. */
41 #include "blockinput.h"
43 /* This may include sys/types.h, and that somehow loses
44 if this is not done before the other system files. */
46 #include <X11/cursorfont.h>
49 /* Load sys/types.h if not already loaded.
50 In some systems loading it twice is suicidal. */
52 #include <sys/types.h>
57 #include <sys/ioctl.h>
59 #else /* ! defined (BSD) */
61 #include <sys/termio.h>
64 #endif /* ! defined (BSD) */
66 /* Allow m- file to inhibit use of FIONREAD. */
67 #ifdef BROKEN_FIONREAD
69 #endif /* ! defined (BROKEN_FIONREAD) */
71 /* We are unable to use interrupts if FIONREAD is not available,
72 so flush SIGIO so we won't try. */
76 #endif /* ! defined (SIGIO) */
86 #include <sys/param.h>
88 #include "dispextern.h"
89 #include "termhooks.h"
103 #define XMapWindow XMapRaised /* Raise them when mapping. */
104 #else /* ! defined (HAVE_X11) */
105 #include <X/Xkeyboard.h>
106 /*#include <X/Xproto.h> */
107 #endif /* ! defined (HAVE_X11) */
109 /* For sending Meta-characters. Do we need this? */
112 #define min(a,b) ((a)<(b) ? (a) : (b))
113 #define max(a,b) ((a)>(b) ? (a) : (b))
115 /* Nonzero means we must reprint all windows
116 because 1) we received an ExposeWindow event
117 or 2) we received too many ExposeRegion events to record.
119 This is never needed under X11. */
120 static int expose_all_windows
;
122 /* Nonzero means we must reprint all icon windows. */
124 static int expose_all_icons
;
127 /* ExposeRegion events, when received, are copied into this queue
128 for later processing. */
130 static struct event_queue x_expose_queue
;
132 /* ButtonPressed and ButtonReleased events, when received,
133 are copied into this queue for later processing. */
135 struct event_queue x_mouse_queue
;
136 #endif /* HAVE_X11 */
138 #if defined (SIGIO) && defined (FIONREAD)
139 int BLOCK_INPUT_mask
;
140 #endif /* ! defined (SIGIO) && defined (FIONREAD) */
142 /* The id of a bitmap used for icon windows.
143 One such map is shared by all Emacs icon windows.
144 This is zero if we have not yet had a need to create the bitmap. */
146 static Bitmap icon_bitmap
;
148 /* Font used for text icons. */
150 static FONT_TYPE
*icon_font_info
;
152 /* Stuff for dealing with the main icon title. */
154 extern Lisp_Object Vcommand_line_args
;
155 char *hostname
, *x_id_name
;
157 /* This is the X connection that we are using. */
159 Display
*x_current_display
;
161 /* The cursor to use for vertical scroll bars on x_current_display. */
162 static Cursor x_vertical_scroll_bar_cursor
;
164 /* Frame being updated by update_frame. This is declared in term.c.
165 This is set by update_begin and looked at by all the
166 XT functions. It is zero while not inside an update.
167 In that case, the XT functions assume that `selected_frame'
168 is the frame to apply to. */
169 extern struct frame
*updating_frame
;
171 /* The frame (if any) which has the X window that has keyboard focus.
172 Zero if none. This is examined by Ffocus_frame in frame.c. Note
173 that a mere EnterNotify event can set this; if you need to know the
174 last frame specified in a FocusIn or FocusOut event, use
175 x_focus_event_frame. */
176 struct frame
*x_focus_frame
;
178 /* The last frame mentioned in a FocusIn or FocusOut event. This is
179 separate from x_focus_frame, because whether or not LeaveNotify
180 events cause us to lose focus depends on whether or not we have
181 received a FocusIn event for it. */
182 struct frame
*x_focus_event_frame
;
184 /* The frame which currently has the visual highlight, and should get
185 keyboard input (other sorts of input have the frame encoded in the
186 event). It points to the X focus frame's selected window's
187 frame. It differs from x_focus_frame when we're using a global
189 static struct frame
*x_highlight_frame
;
191 /* From .Xdefaults, the value of "emacs.WarpMouse". If non-zero,
192 mouse is moved to inside of frame when frame is de-iconified. */
194 static int warp_mouse_on_deiconify
;
196 /* During an update, maximum vpos for ins/del line operations to affect. */
198 static int flexlines
;
200 /* During an update, nonzero if chars output now should be highlighted. */
202 static int highlight
;
204 /* Nominal cursor position -- where to draw output.
205 During an update, these are different from the cursor-box position. */
211 /* `t' if a mouse button is depressed. */
213 extern Lisp_Object Vmouse_depressed
;
215 /* Tells if a window manager is present or not. */
217 extern Lisp_Object Vx_no_window_manager
;
219 /* Timestamp that we requested selection data was made. */
220 extern Time requestor_time
;
222 /* ID of the window requesting selection data. */
223 extern Window requestor_window
;
225 /* Nonzero enables some debugging for the X interface code. */
228 #else /* ! defined (HAVE_X11) */
230 /* Bit patterns for the mouse cursor. */
232 short MouseCursor
[] = {
233 0x0000, 0x0008, 0x0018, 0x0038,
234 0x0078, 0x00f8, 0x01f8, 0x03f8,
235 0x07f8, 0x00f8, 0x00d8, 0x0188,
236 0x0180, 0x0300, 0x0300, 0x0000};
238 short MouseMask
[] = {
239 0x000c, 0x001c, 0x003c, 0x007c,
240 0x00fc, 0x01fc, 0x03fc, 0x07fc,
241 0x0ffc, 0x0ffc, 0x01fc, 0x03dc,
242 0x03cc, 0x0780, 0x0780, 0x0300};
244 static short grey_bits
[] = {
245 0x0005, 0x000a, 0x0005, 0x000a};
247 static Pixmap GreyPixmap
= 0;
248 #endif /* ! defined (HAVE_X11) */
250 /* From time to time we get info on an Emacs window, here. */
252 static WINDOWINFO_TYPE windowinfo
;
256 /* A mask of extra modifier bits to put into every keyboard char. */
257 extern int extra_keyboard_modifiers
;
259 extern Display
*XOpenDisplay ();
260 extern Window
XCreateWindow ();
262 extern Cursor
XCreateCursor ();
263 extern FONT_TYPE
*XOpenFont ();
265 static void flashback ();
268 static void dumpqueue ();
269 #endif /* HAVE_X11 */
272 static int XTcursor_to ();
273 static int XTclear_end_of_line ();
276 /* Starting and ending updates.
278 These hooks are called by update_frame at the beginning and end
279 of a frame update. We record in `updating_frame' the identity
280 of the frame being updated, so that the XT... functions do not
281 need to take a frame as argument. Most of the XT... functions
282 should never be called except during an update, the only exceptions
283 being XTcursor_to, XTwrite_char and XTreassert_line_highlight. */
285 extern int mouse_track_top
, mouse_track_left
, mouse_track_width
;
296 flexlines
= f
->height
;
302 #endif /* HAVE_X11 */
307 static void x_do_pending_expose ();
316 if (updating_frame
== 0
317 || updating_frame
!= f
)
323 x_do_pending_expose ();
324 #endif /* HAVE_X11 */
326 x_display_cursor (f
, 1);
332 /* External interface to control of standout mode.
333 Call this when about to modify line at position VPOS
334 and not change whether it is highlighted. */
336 XTreassert_line_highlight (new, vpos
)
342 /* Call this when about to modify line at position VPOS
343 and change whether it is highlighted. */
346 XTchange_line_highlight (new_highlight
, vpos
, first_unused_hpos
)
347 int new_highlight
, vpos
, first_unused_hpos
;
349 highlight
= new_highlight
;
350 XTcursor_to (vpos
, 0);
351 XTclear_end_of_line (updating_frame
->width
);
354 /* This is used when starting Emacs and when restarting after suspend.
355 When starting Emacs, no X window is mapped. And nothing must be done
356 to Emacs's own window if it is suspended (though that rarely happens). */
359 XTset_terminal_modes ()
363 /* This is called when exiting or suspending Emacs.
364 Exiting will make the X-windows go away, and suspending
365 requires no action. */
368 XTreset_terminal_modes ()
370 /* XTclear_frame (); */
373 /* Set the nominal cursor position of the frame.
374 This is where display update commands will take effect.
375 This does not affect the place where the cursor-box is displayed. */
378 XTcursor_to (row
, col
)
379 register int row
, col
;
387 if (updating_frame
== 0)
390 x_display_cursor (selected_frame
, 1);
396 /* Display a sequence of N glyphs found at GP.
397 WINDOW is the x-window to output to. LEFT and TOP are starting coords.
398 HL is 1 if this text is highlighted, 2 if the cursor is on it.
400 FONT is the default font to use (for glyphs whose font-code is 0).
402 Since the display generation code is responsible for calling
403 compute_char_face and compute_glyph_face on everything it puts in
404 the display structure, we can assume that the face code on each
405 glyph is a valid index into FRAME_FACES (f), and the one to which
406 we can actually apply intern_face. */
409 /* This is the multi-face code. */
412 dumpglyphs (f
, left
, top
, gp
, n
, hl
)
415 register GLYPH
*gp
; /* Points to first GLYPH. */
416 register int n
; /* Number of glyphs to display. */
419 /* Holds characters to be displayed. */
420 char *buf
= (char *) alloca (f
->width
* sizeof (*buf
));
421 register char *cp
; /* Steps through buf[]. */
422 register int tlen
= GLYPH_TABLE_LENGTH
;
423 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
424 Window window
= FRAME_X_WINDOW (f
);
428 /* Get the face-code of the next GLYPH. */
432 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
435 /* Find the run of consecutive glyphs with the same face-code.
436 Extract their character codes into BUF. */
441 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
442 if (GLYPH_FACE (g
) != cf
)
445 *cp
++ = GLYPH_CHAR (g
);
450 /* LEN gets the length of the run. */
453 /* Now output this run of chars, with the font and pixel values
454 determined by the face code CF. */
456 struct face
*face
= FRAME_DEFAULT_FACE (f
);
457 FONT_TYPE
*font
= FACE_FONT (face
);
458 GC gc
= FACE_GC (face
);
460 int gc_temporary
= 0;
462 /* First look at the face of the text itself. */
465 /* The face codes on the glyphs must be valid indices into the
466 frame's face table. */
467 if (cf
< 0 || cf
>= FRAME_N_FACES (f
))
471 face
= FRAME_MODE_LINE_FACE (f
);
473 face
= intern_face (f
, FRAME_FACES (f
) [cf
]);
474 font
= FACE_FONT (face
);
479 /* Then comes the distinction between modeline and normal text. */
484 face
= FRAME_MODE_LINE_FACE (f
);
485 font
= FACE_FONT (face
);
490 #define FACE_DEFAULT (~0)
492 /* Now override that if the cursor's on this character. */
497 || (int) face
->font
== FACE_DEFAULT
)
499 gc
= f
->display
.x
->cursor_gc
;
501 /* Cursor on non-default face: must merge. */
507 xgcv
.background
= f
->display
.x
->cursor_pixel
;
508 xgcv
.foreground
= f
->display
.x
->cursor_foreground_pixel
;
509 xgcv
.font
= face
->font
->fid
;
510 xgcv
.graphics_exposures
= 0;
511 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
512 gc
= XCreateGC (x_current_display
, FRAME_X_WINDOW (f
),
515 if (face
->stipple
&& face
->stipple
!= FACE_DEFAULT
)
516 XSetStipple (x_current_display
, gc
, face
->stipple
);
522 if ((int) font
== FACE_DEFAULT
)
523 font
= f
->display
.x
->font
;
525 XDrawImageString (x_current_display
, window
, gc
,
526 left
, top
+ FONT_BASE (font
), buf
, len
);
529 XFreeGC (x_current_display
, gc
);
531 /* We should probably check for XA_UNDERLINE_POSITION and
532 XA_UNDERLINE_THICKNESS properties on the font, but let's
533 just get the thing working, and come back to that. */
535 int underline_position
= 1;
537 if (font
->descent
<= underline_position
)
538 underline_position
= font
->descent
- 1;
541 XFillRectangle (x_current_display
, FRAME_X_WINDOW (f
),
545 + underline_position
),
546 len
* FONT_WIDTH (font
), 1);
549 left
+= len
* FONT_WIDTH (font
);
556 /* This is the old single-face code. */
559 dumpglyphs (f
, left
, top
, gp
, n
, hl
, font
)
562 register GLYPH
*gp
; /* Points to first GLYPH. */
563 register int n
; /* Number of glyphs to display. */
568 Window window
= FRAME_X_WINDOW (f
);
569 GC drawing_gc
= (hl
== 2 ? f
->display
.x
->cursor_gc
570 : (hl
? f
->display
.x
->reverse_gc
571 : f
->display
.x
->normal_gc
));
573 if (sizeof (GLYPH
) == sizeof (XChar2b
))
574 XDrawImageString16 (x_current_display
, window
, drawing_gc
,
575 left
, top
+ FONT_BASE (font
), (XChar2b
*) gp
, n
);
576 else if (sizeof (GLYPH
) == sizeof (unsigned char))
577 XDrawImageString (x_current_display
, window
, drawing_gc
,
578 left
, top
+ FONT_BASE (font
), (char *) gp
, n
);
580 /* What size of glyph ARE you using? And does X have a function to
586 /* Output some text at the nominal frame cursor position.
587 Advance the cursor over the text.
588 Output LEN glyphs at START.
590 `highlight', set up by XTreassert_line_highlight or XTchange_line_highlight,
591 controls the pixel values used for foreground and background. */
594 XTwrite_glyphs (start
, len
)
595 register GLYPH
*start
;
598 register int temp_length
;
608 /* If not within an update,
609 output at the frame's visible cursor. */
610 curs_x
= f
->cursor_x
;
611 curs_y
= f
->cursor_y
;
615 CHAR_TO_PIXEL_COL (f
, curs_x
),
616 CHAR_TO_PIXEL_ROW (f
, curs_y
),
617 start
, len
, highlight
);
619 /* If we drew on top of the cursor, note that it is turned off. */
620 if (curs_y
== f
->phys_cursor_y
621 && curs_x
<= f
->phys_cursor_x
622 && curs_x
+ len
> f
->phys_cursor_x
)
623 f
->phys_cursor_x
= -1;
625 if (updating_frame
== 0)
628 x_display_cursor (f
, 1);
637 /* Clear to the end of the line.
638 Erase the current text line from the nominal cursor position (inclusive)
639 to column FIRST_UNUSED (exclusive). The idea is that everything
640 from FIRST_UNUSED onward is already erased. */
643 XTclear_end_of_line (first_unused
)
644 register int first_unused
;
646 struct frame
*f
= updating_frame
;
652 if (curs_y
< 0 || curs_y
>= f
->height
)
654 if (first_unused
<= 0)
657 if (first_unused
>= f
->width
)
658 first_unused
= f
->width
;
662 /* Notice if the cursor will be cleared by this operation. */
663 if (curs_y
== f
->phys_cursor_y
664 && curs_x
<= f
->phys_cursor_x
665 && f
->phys_cursor_x
< first_unused
)
666 f
->phys_cursor_x
= -1;
669 XClearArea (x_current_display
, FRAME_X_WINDOW (f
),
670 CHAR_TO_PIXEL_COL (f
, curs_x
),
671 CHAR_TO_PIXEL_ROW (f
, curs_y
),
672 FONT_WIDTH (f
->display
.x
->font
) * (first_unused
- curs_x
),
673 FONT_HEIGHT (f
->display
.x
->font
), False
);
675 #else /* ! defined (HAVE_X11) */
676 XPixSet (FRAME_X_WINDOW (f
),
677 CHAR_TO_PIXEL_COL (f
, curs_x
),
678 CHAR_TO_PIXEL_ROW (f
, curs_y
),
679 FONT_WIDTH (f
->display
.x
->font
) * (first_unused
- curs_x
),
680 FONT_HEIGHT (f
->display
.x
->font
),
681 f
->display
.x
->background_pixel
);
682 #endif /* ! defined (HAVE_X11) */
691 struct frame
*f
= updating_frame
;
696 f
->phys_cursor_x
= -1; /* Cursor not visible. */
697 curs_x
= 0; /* Nominal cursor position is top left. */
702 XClear (FRAME_X_WINDOW (f
));
704 /* We have to clear the scroll bars, too. If we have changed
705 colors or something like that, then they should be notified. */
706 x_scroll_bar_clear (f
);
710 #endif /* HAVE_X11 */
716 /* Invert the middle quarter of the frame for .15 sec. */
718 /* We use the select system call to do the waiting, so we have to make sure
719 it's avaliable. If it isn't, we just won't do visual bells. */
720 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
722 /* Subtract the `struct timeval' values X and Y,
723 storing the result in RESULT.
724 Return 1 if the difference is negative, otherwise 0. */
727 timeval_subtract (result
, x
, y
)
728 struct timeval
*result
, x
, y
;
730 /* Perform the carry for the later subtraction by updating y.
731 This is safer because on some systems
732 the tv_sec member is unsigned. */
733 if (x
.tv_usec
< y
.tv_usec
)
735 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
736 y
.tv_usec
-= 1000000 * nsec
;
739 if (x
.tv_usec
- y
.tv_usec
> 1000000)
741 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
742 y
.tv_usec
+= 1000000 * nsec
;
746 /* Compute the time remaining to wait. tv_usec is certainly positive. */
747 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
748 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
750 /* Return indication of whether the result should be considered negative. */
751 return x
.tv_sec
< y
.tv_sec
;
762 /* Create a GC that will use the GXxor function to flip foreground pixels
763 into background pixels. */
767 values
.function
= GXxor
;
768 values
.foreground
= (f
->display
.x
->foreground_pixel
769 ^ f
->display
.x
->background_pixel
);
771 gc
= XCreateGC (x_current_display
, FRAME_X_WINDOW (f
),
772 GCFunction
| GCForeground
, &values
);
776 int width
= PIXEL_WIDTH (f
);
777 int height
= PIXEL_HEIGHT (f
);
779 XFillRectangle (x_current_display
, FRAME_X_WINDOW (f
), gc
,
780 width
/4, height
/4, width
/2, height
/2);
781 XFlush (x_current_display
);
784 struct timeval wakeup
, now
;
786 gettimeofday (&wakeup
, (struct timezone
*) 0);
788 /* Compute time to wait until, propagating carry from usecs. */
789 wakeup
.tv_usec
+= 150000;
790 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
791 wakeup
.tv_usec
%= 1000000;
793 /* Keep waiting until past the time wakeup. */
796 struct timeval timeout
;
798 gettimeofday (&timeout
, (struct timezone
*)0);
800 /* In effect, timeout = wakeup - timeout.
801 Break if result would be negative. */
802 if (timeval_subtract (&timeout
, wakeup
, timeout
))
805 /* Try to wait that long--but we might wake up sooner. */
806 select (0, 0, 0, 0, &timeout
);
810 XFillRectangle (x_current_display
, FRAME_X_WINDOW (f
), gc
,
811 width
/4, height
/4, width
/2, height
/2);
812 XFreeGC (x_current_display
, gc
);
813 XFlush (x_current_display
);
823 /* Make audible bell. */
826 #define XRINGBELL XBell(x_current_display, 0)
827 #else /* ! defined (HAVE_X11) */
828 #define XRINGBELL XFeep(0);
829 #endif /* ! defined (HAVE_X11) */
833 if (x_current_display
== 0)
836 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
838 XTflash (selected_frame
);
849 /* Insert and delete character.
850 These are not supposed to be used because we are supposed to turn
851 off the feature of using them. */
854 XTinsert_glyphs (start
, len
)
855 register char *start
;
868 /* Specify how many text lines, from the top of the window,
869 should be affected by insert-lines and delete-lines operations.
870 This, and those operations, are used only within an update
871 that is bounded by calls to XTupdate_begin and XTupdate_end. */
874 XTset_terminal_window (n
)
877 if (updating_frame
== 0)
880 if ((n
<= 0) || (n
> updating_frame
->height
))
881 flexlines
= updating_frame
->height
;
886 /* Perform an insert-lines operation.
887 Insert N lines at a vertical position curs_y. */
893 register int topregion
, bottomregion
;
894 register int length
, newtop
, mask
;
895 register struct frame
*f
= updating_frame
;
896 int intborder
= f
->display
.x
->internal_border_width
;
898 if (curs_y
>= flexlines
)
902 bottomregion
= flexlines
- (n
+ 1);
903 newtop
= topregion
+ n
;
904 length
= (bottomregion
- topregion
) + 1;
908 #endif /* HAVE_X11 */
910 if ((length
> 0) && (newtop
<= flexlines
))
913 XCopyArea (x_current_display
, FRAME_X_WINDOW (f
),
914 FRAME_X_WINDOW (f
), f
->display
.x
->normal_gc
,
915 intborder
, CHAR_TO_PIXEL_ROW (f
, topregion
),
916 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
917 length
* FONT_HEIGHT (f
->display
.x
->font
), intborder
,
918 CHAR_TO_PIXEL_ROW (f
, newtop
));
919 #else /* ! defined (HAVE_X11) */
920 XMoveArea (FRAME_X_WINDOW (f
),
921 intborder
, CHAR_TO_PIXEL_ROW (f
, topregion
),
922 intborder
, CHAR_TO_PIXEL_ROW (f
, newtop
),
923 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
924 length
* FONT_HEIGHT (f
->display
.x
->font
));
925 /* Now we must process any ExposeRegion events that occur
926 if the area being copied from is obscured.
927 We can't let it wait because further i/d operations
928 may want to copy this area to another area. */
930 #endif /* ! defined (HAVE_X11) */
933 newtop
= min (newtop
, (flexlines
- 1));
934 length
= newtop
- topregion
;
938 XClearArea (x_current_display
, FRAME_X_WINDOW (f
), intborder
,
939 CHAR_TO_PIXEL_ROW (f
, topregion
),
940 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
941 n
* FONT_HEIGHT (f
->display
.x
->font
), False
);
942 #else /* ! defined (HAVE_X11) */
943 XPixSet (FRAME_X_WINDOW (f
),
945 CHAR_TO_PIXEL_ROW (f
, topregion
),
946 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
947 n
* FONT_HEIGHT (f
->display
.x
->font
),
948 f
->display
.x
->background_pixel
);
949 #endif /* ! defined (HAVE_X11) */
953 /* Perform a delete-lines operation, deleting N lines
954 at a vertical position curs_y. */
961 register struct frame
*f
= updating_frame
;
962 int intborder
= f
->display
.x
->internal_border_width
;
964 if (curs_y
>= flexlines
)
969 #endif /* HAVE_X11 */
971 if ((curs_y
+ n
) >= flexlines
)
973 if (flexlines
>= (curs_y
+ 1))
976 XClearArea (x_current_display
, FRAME_X_WINDOW (f
), intborder
,
977 CHAR_TO_PIXEL_ROW (f
, curs_y
),
978 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
979 (flexlines
- curs_y
) * FONT_HEIGHT (f
->display
.x
->font
), False
);
980 #else /* ! defined (HAVE_X11) */
981 XPixSet (FRAME_X_WINDOW (f
),
982 intborder
, CHAR_TO_PIXEL_ROW (f
, curs_y
),
983 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
984 (flexlines
- curs_y
) * FONT_HEIGHT (f
->display
.x
->font
),
985 f
->display
.x
->background_pixel
);
986 #endif /* ! defined (HAVE_X11) */
992 XCopyArea (x_current_display
, FRAME_X_WINDOW (f
),
993 FRAME_X_WINDOW (f
), f
->display
.x
->normal_gc
,
995 CHAR_TO_PIXEL_ROW (f
, curs_y
+ n
),
996 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
997 (flexlines
- (curs_y
+ n
)) * FONT_HEIGHT (f
->display
.x
->font
),
998 intborder
, CHAR_TO_PIXEL_ROW (f
, curs_y
));
999 XClearArea (x_current_display
, FRAME_X_WINDOW (f
),
1001 CHAR_TO_PIXEL_ROW (f
, flexlines
- n
),
1002 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
1003 n
* FONT_HEIGHT (f
->display
.x
->font
), False
);
1004 #else /* ! defined (HAVE_X11) */
1005 XMoveArea (FRAME_X_WINDOW (f
),
1007 CHAR_TO_PIXEL_ROW (f
, curs_y
+ n
),
1008 intborder
, CHAR_TO_PIXEL_ROW (f
, curs_y
),
1009 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
1010 (flexlines
- (curs_y
+ n
)) * FONT_HEIGHT (f
->display
.x
->font
));
1011 /* Now we must process any ExposeRegion events that occur
1012 if the area being copied from is obscured.
1013 We can't let it wait because further i/d operations
1014 may want to copy this area to another area. */
1016 XPixSet (FRAME_X_WINDOW (f
), intborder
,
1017 CHAR_TO_PIXEL_ROW (f
, flexlines
- n
),
1018 f
->width
* FONT_WIDTH (f
->display
.x
->font
),
1019 n
* FONT_HEIGHT (f
->display
.x
->font
), f
->display
.x
->background_pixel
);
1020 #endif /* ! defined (HAVE_X11) */
1024 /* Perform an insert-lines or delete-lines operation,
1025 inserting N lines or deleting -N lines at vertical position VPOS. */
1027 XTins_del_lines (vpos
, n
)
1030 if (updating_frame
== 0)
1033 /* Hide the cursor. */
1034 x_display_cursor (updating_frame
, 0);
1036 XTcursor_to (vpos
, 0);
1047 /* Support routines for exposure events. */
1048 static void clear_cursor ();
1050 /* Output into a rectangle of an X-window (for frame F)
1051 the characters in f->phys_lines that overlap that rectangle.
1052 TOP and LEFT are the position of the upper left corner of the rectangle.
1053 ROWS and COLS are the size of the rectangle. */
1056 dumprectangle (f
, left
, top
, cols
, rows
)
1058 register int left
, top
, cols
, rows
;
1060 register struct frame_glyphs
*active_frame
= FRAME_CURRENT_GLYPHS (f
);
1061 int cursor_cleared
= 0;
1065 if (FRAME_GARBAGED_P (f
))
1068 /* Express rectangle as four edges, instead of position-and-size. */
1069 bottom
= top
+ rows
;
1070 right
= left
+ cols
;
1072 #ifndef HAVE_X11 /* Window manger does this for X11. */
1074 int intborder
= f
->display
.x
->internal_border_width
;
1076 /* If the rectangle includes any of the internal border area,
1077 redisplay the border emphasis. */
1078 if (top
< intborder
|| left
< intborder
1079 || bottom
> intborder
+ f
->height
* FONT_HEIGHT (f
->display
.x
->font
)
1080 || right
> intborder
+ f
->width
* FONT_WIDTH (f
->display
.x
->font
))
1083 #endif /* HAVE_X11 /* Window manger does this for X11. */ */
1085 /* Convert rectangle edges in pixels to edges in chars.
1086 Round down for left and top, up for right and bottom. */
1087 top
= PIXEL_TO_CHAR_ROW (f
, top
);
1088 left
= PIXEL_TO_CHAR_COL (f
, left
);
1089 bottom
+= (FONT_HEIGHT (f
->display
.x
->font
) - 1);
1090 right
+= (FONT_WIDTH (f
->display
.x
->font
) - 1);
1091 bottom
= PIXEL_TO_CHAR_ROW (f
, bottom
);
1092 right
= PIXEL_TO_CHAR_COL (f
, right
);
1094 /* Clip the rectangle to what can be visible. */
1099 if (right
> f
->width
)
1101 if (bottom
> f
->height
)
1104 /* Get size in chars of the rectangle. */
1105 cols
= right
- left
;
1106 rows
= bottom
- top
;
1108 /* If rectangle has zero area, return. */
1109 if (rows
<= 0) return;
1110 if (cols
<= 0) return;
1112 /* Turn off the cursor if it is in the rectangle.
1113 We will turn it back on afterward. */
1114 if ((f
->phys_cursor_x
>= left
) && (f
->phys_cursor_x
< right
)
1115 && (f
->phys_cursor_y
>= top
) && (f
->phys_cursor_y
< bottom
))
1121 /* Display the text in the rectangle, one text line at a time. */
1123 for (y
= top
; y
< bottom
; y
++)
1125 GLYPH
*line
= &active_frame
->glyphs
[y
][left
];
1127 if (! active_frame
->enable
[y
] || left
> active_frame
->used
[y
])
1131 CHAR_TO_PIXEL_COL (f
, left
),
1132 CHAR_TO_PIXEL_ROW (f
, y
),
1133 line
, min (cols
, active_frame
->used
[y
] - left
),
1134 active_frame
->highlight
[y
]);
1137 /* Turn the cursor on if we turned it off. */
1140 x_display_cursor (f
, 1);
1144 /* Process all queued ExposeRegion events. */
1150 XExposeRegionEvent r
;
1152 while (dequeue_event (&r
, &x_expose_queue
))
1154 struct frame
*f
= x_window_to_frame (r
.window
);
1155 if (f
->display
.x
->icon_desc
== r
.window
)
1158 dumprectangle (f
, r
.x
, r
.y
, r
.width
, r
.height
);
1162 #endif /* HAVE_X11 */
1164 /* Process all expose events that are pending, for X10.
1165 Redraws the cursor if necessary on any frame that
1166 is not in the process of being updated with update_frame. */
1170 x_do_pending_expose ()
1174 Lisp_Object tail
, frame
;
1176 if (expose_all_windows
)
1178 expose_all_windows
= 0;
1179 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1181 register int temp_width
, temp_height
;
1184 frame
= XCONS (tail
)->car
;
1185 if (XGCTYPE (frame
) != Lisp_Frame
)
1188 if (! FRAME_X_P (f
))
1190 if (!f
->async_visible
)
1192 if (!f
->display
.x
->needs_exposure
)
1195 intborder
= f
->display
.x
->internal_border_width
;
1198 XGetWindowInfo (FRAME_X_WINDOW (f
), &windowinfo
);
1199 temp_width
= ((windowinfo
.width
- 2 * intborder
1200 - f
->display
.x
->v_scroll_bar_width
)
1201 / FONT_WIDTH (f
->display
.x
->font
));
1202 temp_height
= ((windowinfo
.height
- 2 * intborder
1203 - f
->display
.x
->h_scroll_bar_height
)
1204 / FONT_HEIGHT (f
->display
.x
->font
));
1205 if (temp_width
!= f
->width
|| temp_height
!= f
->height
)
1207 change_frame_size (f
, max (1, temp_height
),
1208 max (1, temp_width
), 0, 1);
1209 x_resize_scroll_bars (f
);
1211 f
->display
.x
->left_pos
= windowinfo
.x
;
1212 f
->display
.x
->top_pos
= windowinfo
.y
;
1213 dumprectangle (f
, 0, 0, PIXEL_WIDTH (f
), PIXEL_HEIGHT (f
));
1217 f
->display
.x
->needs_exposure
= 0;
1218 if (updating_frame
!= f
)
1219 x_display_cursor (f
, 1);
1224 /* Handle any individual-rectangle expose events queued
1225 for various windows. */
1228 #else /* ! defined (HAVE_X11) */
1230 #endif /* ! defined (HAVE_X11) */
1236 frame_highlight (frame
)
1237 struct frame
*frame
;
1239 if (! EQ (Vx_no_window_manager
, Qnil
))
1240 XSetWindowBorder (x_current_display
, FRAME_X_WINDOW (frame
),
1241 frame
->display
.x
->border_pixel
);
1242 x_display_cursor (frame
, 1);
1246 frame_unhighlight (frame
)
1247 struct frame
*frame
;
1249 if (! EQ (Vx_no_window_manager
, Qnil
))
1250 XSetWindowBorderPixmap (x_current_display
, FRAME_X_WINDOW (frame
),
1251 frame
->display
.x
->border_tile
);
1252 x_display_cursor (frame
, 1);
1254 #else /* ! defined (HAVE_X11) */
1255 /* Dump the border-emphasis of frame F.
1256 If F is selected, this is a lining of the same color as the border,
1257 just within the border, occupying a portion of the internal border.
1258 If F is not selected, it is background in the same place.
1259 If ALWAYS is 0, don't bother explicitly drawing if it's background.
1261 ALWAYS = 1 is used when a frame becomes selected or deselected.
1262 In that case, we also turn the cursor off and on again
1263 so it will appear in the proper shape (solid if selected; else hollow.) */
1266 dumpborder (f
, always
)
1270 int thickness
= f
->display
.x
->internal_border_width
/ 2;
1271 int width
= PIXEL_WIDTH (f
);
1272 int height
= PIXEL_HEIGHT (f
);
1275 if (f
!= selected_frame
)
1280 pixel
= f
->display
.x
->background_pixel
;
1284 pixel
= f
->display
.x
->border_pixel
;
1287 XPixSet (FRAME_X_WINDOW (f
), 0, 0, width
, thickness
, pixel
);
1288 XPixSet (FRAME_X_WINDOW (f
), 0, 0, thickness
, height
, pixel
);
1289 XPixSet (FRAME_X_WINDOW (f
), 0, height
- thickness
, width
,
1291 XPixSet (FRAME_X_WINDOW (f
), width
- thickness
, 0, thickness
,
1295 x_display_cursor (f
, 1);
1297 #endif /* ! defined (HAVE_X11) */
1299 static void XTframe_rehighlight ();
1301 /* The focus has changed. Update the frames as necessary to reflect
1302 the new situation. Note that we can't change the selected frame
1303 here, because the lisp code we are interrupting might become confused.
1304 Each event gets marked with the frame in which it occured, so the
1305 lisp code can tell when the switch took place by examining the events. */
1308 x_new_focus_frame (frame
)
1309 struct frame
*frame
;
1311 struct frame
*old_focus
= x_focus_frame
;
1312 int events_enqueued
= 0;
1314 if (frame
!= x_focus_frame
)
1316 /* Set this before calling other routines, so that they see
1317 the correct value of x_focus_frame. */
1318 x_focus_frame
= frame
;
1320 if (old_focus
&& old_focus
->auto_lower
)
1321 x_lower_frame (old_focus
);
1324 selected_frame
= frame
;
1325 XSET (XWINDOW (selected_frame
->selected_window
)->frame
,
1326 Lisp_Frame
, selected_frame
);
1327 Fselect_window (selected_frame
->selected_window
);
1328 choose_minibuf_frame ();
1331 if (x_focus_frame
&& x_focus_frame
->auto_raise
)
1332 x_raise_frame (x_focus_frame
);
1335 XTframe_rehighlight ();
1339 /* The focus has changed, or we have redirected a frame's focus to
1340 another frame (this happens when a frame uses a surrogate
1341 minibuffer frame). Shift the highlight as appropriate. */
1343 XTframe_rehighlight ()
1345 struct frame
*old_highlight
= x_highlight_frame
;
1350 ((XGCTYPE (FRAME_FOCUS_FRAME (x_focus_frame
)) == Lisp_Frame
)
1351 ? XFRAME (FRAME_FOCUS_FRAME (x_focus_frame
))
1353 if (! FRAME_LIVE_P (x_highlight_frame
))
1355 FRAME_FOCUS_FRAME (x_focus_frame
) = Qnil
;
1356 x_highlight_frame
= x_focus_frame
;
1360 x_highlight_frame
= 0;
1362 if (x_highlight_frame
!= old_highlight
)
1365 frame_unhighlight (old_highlight
);
1366 if (x_highlight_frame
)
1367 frame_highlight (x_highlight_frame
);
1371 /* Mouse clicks and mouse movement. Rah. */
1374 /* Given a pixel position (PIX_X, PIX_Y) on the frame F, return
1375 glyph co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle
1376 that the glyph at X, Y occupies, if BOUNDS != 0. */
1378 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
)
1380 register unsigned int pix_x
, pix_y
;
1381 register int *x
, *y
;
1384 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
1385 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
1389 bounds
->width
= FONT_WIDTH (f
->display
.x
->font
);
1390 bounds
->height
= FONT_HEIGHT (f
->display
.x
->font
);
1391 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
1392 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
1395 if (pix_x
< 0) pix_x
= 0;
1396 else if (pix_x
> f
->width
) pix_x
= f
->width
;
1398 if (pix_y
< 0) pix_y
= 0;
1399 else if (pix_y
> f
->height
) pix_y
= f
->height
;
1405 /* Any buttons grabbed. */
1406 unsigned int x_mouse_grabbed
;
1408 /* Which modifier keys are on which modifier bits?
1410 With each keystroke, X returns eight bits indicating which modifier
1411 keys were held down when the key was pressed. The interpretation
1412 of the top five modifier bits depends on what keys are attached
1413 to them. If the Meta_L and Meta_R keysyms are on mod5, then mod5
1416 x_meta_mod_mask is a mask containing the bits used for the meta key.
1417 It may have more than one bit set, if more than one modifier bit
1418 has meta keys on it. Basically, if EVENT is a KeyPress event,
1419 the meta key is pressed if (EVENT.state & x_meta_mod_mask) != 0.
1421 x_shift_lock_mask is LockMask if the XK_Shift_Lock keysym is on the
1422 lock modifier bit, or zero otherwise. Non-alphabetic keys should
1423 only be affected by the lock modifier bit if XK_Shift_Lock is in
1424 use; XK_Caps_Lock should only affect alphabetic keys. With this
1425 arrangement, the lock modifier should shift the character if
1426 (EVENT.state & x_shift_lock_mask) != 0. */
1427 static int x_meta_mod_mask
, x_shift_lock_mask
;
1429 /* These are like x_meta_mod_mask, but for different modifiers. */
1430 static int x_alt_mod_mask
, x_super_mod_mask
, x_hyper_mod_mask
;
1432 /* Initialize mode_switch_bit and modifier_meaning. */
1434 x_find_modifier_meanings ()
1436 int min_code
, max_code
;
1439 XModifierKeymap
*mods
;
1441 x_meta_mod_mask
= 0;
1442 x_shift_lock_mask
= 0;
1444 x_super_mod_mask
= 0;
1445 x_hyper_mod_mask
= 0;
1448 XDisplayKeycodes (x_current_display
, &min_code
, &max_code
);
1450 min_code
= x_current_display
->min_keycode
;
1451 max_code
= x_current_display
->max_keycode
;
1454 syms
= XGetKeyboardMapping (x_current_display
,
1455 min_code
, max_code
- min_code
+ 1,
1457 mods
= XGetModifierMapping (x_current_display
);
1459 /* Scan the modifier table to see which modifier bits the Meta and
1460 Alt keysyms are on. */
1462 int row
, col
; /* The row and column in the modifier table. */
1464 for (row
= 3; row
< 8; row
++)
1465 for (col
= 0; col
< mods
->max_keypermod
; col
++)
1468 mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
1470 /* Are any of this keycode's keysyms a meta key? */
1474 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
1476 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
1482 x_meta_mod_mask
|= (1 << row
);
1487 x_alt_mod_mask
|= (1 << row
);
1492 x_hyper_mod_mask
|= (1 << row
);
1497 x_super_mod_mask
|= (1 << row
);
1501 /* Ignore this if it's not on the lock modifier. */
1502 if ((1 << row
) == LockMask
)
1503 x_shift_lock_mask
= LockMask
;
1511 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
1512 if (! x_meta_mod_mask
)
1514 x_meta_mod_mask
= x_alt_mod_mask
;
1518 /* If some keys are both alt and meta,
1519 make them just meta, not alt. */
1520 if (x_alt_mod_mask
& x_meta_mod_mask
)
1522 x_alt_mod_mask
&= ~x_meta_mod_mask
;
1525 XFree ((char *) syms
);
1526 XFreeModifiermap (mods
);
1530 /* Convert between the modifier bits X uses and the modifier bits
1533 x_x_to_emacs_modifiers (state
)
1536 return ( ((state
& (ShiftMask
| x_shift_lock_mask
)) ? shift_modifier
: 0)
1537 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
1538 | ((state
& x_meta_mod_mask
) ? meta_modifier
: 0)
1539 | ((state
& x_alt_mod_mask
) ? alt_modifier
: 0)
1540 | ((state
& x_super_mod_mask
) ? super_modifier
: 0)
1541 | ((state
& x_hyper_mod_mask
) ? hyper_modifier
: 0));
1545 x_emacs_to_x_modifiers (state
)
1548 return ( ((state
& alt_modifier
) ? x_alt_mod_mask
: 0)
1549 | ((state
& super_modifier
) ? x_super_mod_mask
: 0)
1550 | ((state
& hyper_modifier
) ? x_hyper_mod_mask
: 0)
1551 | ((state
& shift_modifier
) ? ShiftMask
: 0)
1552 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
1553 | ((state
& meta_modifier
) ? x_meta_mod_mask
: 0));
1556 /* Prepare a mouse-event in *RESULT for placement in the input queue.
1558 If the event is a button press, then note that we have grabbed
1562 construct_mouse_click (result
, event
, f
)
1563 struct input_event
*result
;
1564 XButtonEvent
*event
;
1567 /* Make the event type no_event; we'll change that when we decide
1569 result
->kind
= mouse_click
;
1570 XSET (result
->code
, Lisp_Int
, event
->button
- Button1
);
1571 result
->timestamp
= event
->time
;
1572 result
->modifiers
= (x_x_to_emacs_modifiers (event
->state
)
1573 | (event
->type
== ButtonRelease
1577 /* Notice if the mouse is still grabbed. */
1578 if (event
->type
== ButtonPress
)
1580 if (! x_mouse_grabbed
)
1581 Vmouse_depressed
= Qt
;
1582 x_mouse_grabbed
|= (1 << event
->button
);
1584 else if (event
->type
== ButtonRelease
)
1586 x_mouse_grabbed
&= ~(1 << event
->button
);
1587 if (!x_mouse_grabbed
)
1588 Vmouse_depressed
= Qnil
;
1594 pixel_to_glyph_coords (f
, event
->x
, event
->y
, &column
, &row
, NULL
);
1595 XFASTINT (result
->x
) = column
;
1596 XFASTINT (result
->y
) = row
;
1597 XSET (result
->frame_or_window
, Lisp_Frame
, f
);
1602 /* Mouse movement. Rah.
1604 In order to avoid asking for motion events and then throwing most
1605 of them away or busy-polling the server for mouse positions, we ask
1606 the server for pointer motion hints. This means that we get only
1607 one event per group of mouse movements. "Groups" are delimited by
1608 other kinds of events (focus changes and button clicks, for
1609 example), or by XQueryPointer calls; when one of these happens, we
1610 get another MotionNotify event the next time the mouse moves. This
1611 is at least as efficient as getting motion events when mouse
1612 tracking is on, and I suspect only negligibly worse when tracking
1615 The silly O'Reilly & Associates Nutshell guides barely document
1616 pointer motion hints at all (I think you have to infer how they
1617 work from an example), and the description of XQueryPointer doesn't
1618 mention that calling it causes you to get another motion hint from
1619 the server, which is very important. */
1621 /* Where the mouse was last time we reported a mouse event. */
1622 static FRAME_PTR last_mouse_frame
;
1623 static XRectangle last_mouse_glyph
;
1625 /* The scroll bar in which the last X motion event occurred.
1627 If the last X motion event occured in a scroll bar, we set this
1628 so XTmouse_position can know whether to report a scroll bar motion or
1631 If the last X motion event didn't occur in a scroll bar, we set this
1632 to Qnil, to tell XTmouse_position to return an ordinary motion event. */
1633 static Lisp_Object last_mouse_scroll_bar
;
1635 /* This is a hack. We would really prefer that XTmouse_position would
1636 return the time associated with the position it returns, but there
1637 doesn't seem to be any way to wrest the timestamp from the server
1638 along with the position query. So, we just keep track of the time
1639 of the last movement we received, and return that in hopes that
1640 it's somewhat accurate. */
1641 static Time last_mouse_movement_time
;
1643 /* Function to report a mouse movement to the mainstream Emacs code.
1644 The input handler calls this.
1646 We have received a mouse movement event, which is given in *event.
1647 If the mouse is over a different glyph than it was last time, tell
1648 the mainstream emacs code by setting mouse_moved. If not, ask for
1649 another motion event, so we can check again the next time it moves. */
1651 note_mouse_movement (frame
, event
)
1653 XMotionEvent
*event
;
1656 last_mouse_movement_time
= event
->time
;
1658 /* Has the mouse moved off the glyph it was on at the last sighting? */
1659 if (event
->x
< last_mouse_glyph
.x
1660 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
1661 || event
->y
< last_mouse_glyph
.y
1662 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
1665 last_mouse_scroll_bar
= Qnil
;
1669 /* It's on the same glyph. Call XQueryPointer so we'll get an
1670 event the next time the mouse moves and we can see if it's
1671 *still* on the same glyph. */
1674 XQueryPointer (event
->display
, event
->window
,
1675 (Window
*) &dummy
, (Window
*) &dummy
,
1676 &dummy
, &dummy
, &dummy
, &dummy
,
1677 (unsigned int *) &dummy
);
1681 static struct scroll_bar
*x_window_to_scroll_bar ();
1682 static void x_scroll_bar_report_motion ();
1684 /* Return the current position of the mouse.
1686 If the mouse movement started in a scroll bar, set *f, *bar_window,
1687 and *part to the frame, window, and scroll bar part that the mouse
1688 is over. Set *x and *y to the portion and whole of the mouse's
1689 position on the scroll bar.
1691 If the mouse movement started elsewhere, set *f to the frame the
1692 mouse is on, *bar_window to nil, and *x and *y to the character cell
1695 Set *time to the server timestamp for the time at which the mouse
1696 was at this position.
1698 This clears the mouse_moved flag, so we can wait for the next mouse
1699 movement. This also calls XQueryPointer, which will cause the
1700 server to give us another MotionNotify when the mouse moves
1704 XTmouse_position (f
, bar_window
, part
, x
, y
, time
)
1706 Lisp_Object
*bar_window
;
1707 enum scroll_bar_part
*part
;
1709 unsigned long *time
;
1713 if (! NILP (last_mouse_scroll_bar
))
1714 x_scroll_bar_report_motion (f
, bar_window
, part
, x
, y
, time
);
1720 Window dummy_window
;
1724 last_mouse_scroll_bar
= Qnil
;
1726 /* Figure out which root window we're on. */
1727 XQueryPointer (x_current_display
,
1728 DefaultRootWindow (x_current_display
),
1730 /* The root window which contains the pointer. */
1733 /* Trash which we can't trust if the pointer is on
1734 a different screen. */
1737 /* The position on that root window. */
1740 /* More trash we can't trust. */
1743 /* Modifier keys and pointer buttons, about which
1745 (unsigned int *) &dummy
);
1747 /* Now we have a position on the root; find the innermost window
1748 containing the pointer. */
1752 int parent_x
, parent_y
;
1757 XTranslateCoordinates (x_current_display
,
1759 /* From-window, to-window. */
1762 /* From-position, to-position. */
1763 root_x
, root_y
, &win_x
, &win_y
,
1776 /* Now we know that:
1777 win is the innermost window containing the pointer
1778 (XTC says it has no child containing the pointer),
1779 win_x and win_y are the pointer's position in it
1780 (XTC did this the last time through), and
1781 parent_x and parent_y are the pointer's position in win's parent.
1782 (They are what win_x and win_y were when win was child.
1783 If win is the root window, it has no parent, and
1784 parent_{x,y} are invalid, but that's okay, because we'll
1785 never use them in that case.) */
1787 /* Is win one of our frames? */
1788 *f
= x_window_to_frame (win
);
1790 /* If not, is it one of our scroll bars? */
1793 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
1797 *f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1805 pixel_to_glyph_coords (*f
, win_x
, win_y
, &win_x
, &win_y
,
1810 XSET (*x
, Lisp_Int
, win_x
);
1811 XSET (*y
, Lisp_Int
, win_y
);
1812 *time
= last_mouse_movement_time
;
1820 #else /* ! defined (HAVE_X11) */
1821 #define XEvent XKeyPressedEvent
1822 #endif /* ! defined (HAVE_X11) */
1824 /* Scroll bar support. */
1826 /* Given an X window ID, find the struct scroll_bar which manages it.
1827 This can be called in GC, so we have to make sure to strip off mark
1829 static struct scroll_bar
*
1830 x_window_to_scroll_bar (window_id
)
1833 Lisp_Object tail
, frame
;
1835 for (tail
= Vframe_list
;
1836 XGCTYPE (tail
) == Lisp_Cons
;
1837 tail
= XCONS (tail
)->cdr
)
1839 Lisp_Object frame
= XCONS (tail
)->car
;
1840 Lisp_Object bar
, condemned
;
1842 /* All elements of Vframe_list should be frames. */
1843 if (XGCTYPE (frame
) != Lisp_Frame
)
1846 /* Scan this frame's scroll bar list for a scroll bar with the
1848 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
1849 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
1850 /* This trick allows us to search both the ordinary and
1851 condemned scroll bar lists with one loop. */
1852 ! GC_NILP (bar
) || (bar
= condemned
,
1855 bar
= XSCROLL_BAR(bar
)->next
)
1856 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
1857 return XSCROLL_BAR (bar
);
1863 /* Open a new X window to serve as a scroll bar, and return the
1864 scroll bar vector for it. */
1865 static struct scroll_bar
*
1866 x_scroll_bar_create (window
, top
, left
, width
, height
)
1867 struct window
*window
;
1868 int top
, left
, width
, height
;
1870 FRAME_PTR frame
= XFRAME (WINDOW_FRAME (window
));
1871 struct scroll_bar
*bar
=
1872 XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
1877 XSetWindowAttributes a
;
1880 a
.background_pixel
= frame
->display
.x
->background_pixel
;
1881 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
1882 | ButtonMotionMask
| PointerMotionHintMask
1884 a
.cursor
= x_vertical_scroll_bar_cursor
;
1886 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
1888 SET_SCROLL_BAR_X_WINDOW
1890 XCreateWindow (x_current_display
, FRAME_X_WINDOW (frame
),
1892 /* Position and size of scroll bar. */
1893 left
, top
, width
, height
,
1895 /* Border width, depth, class, and visual. */
1896 0, CopyFromParent
, CopyFromParent
, CopyFromParent
,
1902 XSET (bar
->window
, Lisp_Window
, window
);
1903 XSET (bar
->top
, Lisp_Int
, top
);
1904 XSET (bar
->left
, Lisp_Int
, left
);
1905 XSET (bar
->width
, Lisp_Int
, width
);
1906 XSET (bar
->height
, Lisp_Int
, height
);
1907 XSET (bar
->start
, Lisp_Int
, 0);
1908 XSET (bar
->end
, Lisp_Int
, 0);
1909 bar
->dragging
= Qnil
;
1911 /* Add bar to its frame's list of scroll bars. */
1912 bar
->next
= FRAME_SCROLL_BARS (frame
);
1914 XSET (FRAME_SCROLL_BARS (frame
), Lisp_Vector
, bar
);
1915 if (! NILP (bar
->next
))
1916 XSET (XSCROLL_BAR (bar
->next
)->prev
, Lisp_Vector
, bar
);
1918 XMapWindow (x_current_display
, SCROLL_BAR_X_WINDOW (bar
));
1925 /* Draw BAR's handle in the proper position.
1926 If the handle is already drawn from START to END, don't bother
1927 redrawing it, unless REBUILD is non-zero; in that case, always
1928 redraw it. (REBUILD is handy for drawing the handle after expose
1931 Normally, we want to constrain the start and end of the handle to
1932 fit inside its rectangle, but if the user is dragging the scroll bar
1933 handle, we want to let them drag it down all the way, so that the
1934 bar's top is as far down as it goes; otherwise, there's no way to
1935 move to the very end of the buffer. */
1937 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
1938 struct scroll_bar
*bar
;
1942 int dragging
= ! NILP (bar
->dragging
);
1943 Window w
= SCROLL_BAR_X_WINDOW (bar
);
1944 GC gc
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))->display
.x
->normal_gc
;
1946 /* If the display is already accurate, do nothing. */
1948 && start
== XINT (bar
->start
)
1949 && end
== XINT (bar
->end
))
1955 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (XINT (bar
->width
));
1956 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
1957 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
1959 /* Make sure the values are reasonable, and try to preserve
1960 the distance between start and end. */
1962 int length
= end
- start
;
1966 else if (start
> top_range
)
1968 end
= start
+ length
;
1972 else if (end
> top_range
&& ! dragging
)
1976 /* Store the adjusted setting in the scroll bar. */
1977 XSET (bar
->start
, Lisp_Int
, start
);
1978 XSET (bar
->end
, Lisp_Int
, end
);
1980 /* Clip the end position, just for display. */
1981 if (end
> top_range
)
1984 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
1985 below top positions, to make sure the handle is always at least
1986 that many pixels tall. */
1987 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
1989 /* Draw the empty space above the handle. Note that we can't clear
1990 zero-height areas; that means "clear to end of window." */
1992 XClearArea (x_current_display
, w
,
1994 /* x, y, width, height, and exposures. */
1995 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
1996 VERTICAL_SCROLL_BAR_TOP_BORDER
,
1997 inside_width
, start
,
2000 /* Draw the handle itself. */
2001 XFillRectangle (x_current_display
, w
, gc
,
2003 /* x, y, width, height */
2004 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2005 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
2006 inside_width
, end
- start
);
2009 /* Draw the empty space below the handle. Note that we can't
2010 clear zero-height areas; that means "clear to end of window." */
2011 if (end
< inside_height
)
2012 XClearArea (x_current_display
, w
,
2014 /* x, y, width, height, and exposures. */
2015 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
2016 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
2017 inside_width
, inside_height
- end
,
2025 /* Move a scroll bar around on the screen, to accomodate changing
2026 window configurations. */
2028 x_scroll_bar_move (bar
, top
, left
, width
, height
)
2029 struct scroll_bar
*bar
;
2030 int top
, left
, width
, height
;
2036 unsigned int mask
= 0;
2043 if (left
!= XINT (bar
->left
)) mask
|= CWX
;
2044 if (top
!= XINT (bar
->top
)) mask
|= CWY
;
2045 if (width
!= XINT (bar
->width
)) mask
|= CWWidth
;
2046 if (height
!= XINT (bar
->height
)) mask
|= CWHeight
;
2049 XConfigureWindow (x_current_display
, SCROLL_BAR_X_WINDOW (bar
),
2053 XSET (bar
->left
, Lisp_Int
, left
);
2054 XSET (bar
->top
, Lisp_Int
, top
);
2055 XSET (bar
->width
, Lisp_Int
, width
);
2056 XSET (bar
->height
, Lisp_Int
, height
);
2061 /* Destroy the X window for BAR, and set its Emacs window's scroll bar
2064 x_scroll_bar_remove (bar
)
2065 struct scroll_bar
*bar
;
2067 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2071 /* Destroy the window. */
2072 XDestroyWindow (x_current_display
, SCROLL_BAR_X_WINDOW (bar
));
2074 /* Disassociate this scroll bar from its window. */
2075 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
2080 /* Set the handle of the vertical scroll bar for WINDOW to indicate
2081 that we are displaying PORTION characters out of a total of WHOLE
2082 characters, starting at POSITION. If WINDOW has no scroll bar,
2085 XTset_vertical_scroll_bar (window
, portion
, whole
, position
)
2086 struct window
*window
;
2087 int portion
, whole
, position
;
2089 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2090 int top
= XINT (window
->top
);
2091 int left
= WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window
);
2092 int height
= WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window
);
2094 /* Where should this scroll bar be, pixelwise? */
2095 int pixel_top
= CHAR_TO_PIXEL_ROW (f
, top
);
2096 int pixel_left
= CHAR_TO_PIXEL_COL (f
, left
);
2097 int pixel_width
= VERTICAL_SCROLL_BAR_PIXEL_WIDTH (f
);
2098 int pixel_height
= VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f
, height
);
2100 struct scroll_bar
*bar
;
2102 /* Does the scroll bar exist yet? */
2103 if (NILP (window
->vertical_scroll_bar
))
2104 bar
= x_scroll_bar_create (window
,
2105 pixel_top
, pixel_left
,
2106 pixel_width
, pixel_height
);
2109 /* It may just need to be moved and resized. */
2110 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2111 x_scroll_bar_move (bar
, pixel_top
, pixel_left
, pixel_width
, pixel_height
);
2114 /* Set the scroll bar's current state, unless we're currently being
2116 if (NILP (bar
->dragging
))
2119 VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height
);
2122 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
2125 int start
= (position
* top_range
) / whole
;
2126 int end
= ((position
+ portion
) * top_range
) / whole
;
2128 x_scroll_bar_set_handle (bar
, start
, end
, 0);
2132 XSET (window
->vertical_scroll_bar
, Lisp_Vector
, bar
);
2136 /* The following three hooks are used when we're doing a thorough
2137 redisplay of the frame. We don't explicitly know which scroll bars
2138 are going to be deleted, because keeping track of when windows go
2139 away is a real pain - "Can you say set-window-configuration, boys
2140 and girls?" Instead, we just assert at the beginning of redisplay
2141 that *all* scroll bars are to be removed, and then save a scroll bar
2142 from the fiery pit when we actually redisplay its window. */
2144 /* Arrange for all scroll bars on FRAME to be removed at the next call
2145 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
2146 `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
2148 XTcondemn_scroll_bars (frame
)
2151 /* The condemned list should be empty at this point; if it's not,
2152 then the rest of Emacs isn't using the condemn/redeem/judge
2153 protocol correctly. */
2154 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
2157 /* Move them all to the "condemned" list. */
2158 FRAME_CONDEMNED_SCROLL_BARS (frame
) = FRAME_SCROLL_BARS (frame
);
2159 FRAME_SCROLL_BARS (frame
) = Qnil
;
2162 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
2163 Note that WINDOW isn't necessarily condemned at all. */
2165 XTredeem_scroll_bar (window
)
2166 struct window
*window
;
2168 struct scroll_bar
*bar
;
2170 /* We can't redeem this window's scroll bar if it doesn't have one. */
2171 if (NILP (window
->vertical_scroll_bar
))
2174 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2176 /* Unlink it from the condemned list. */
2178 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2180 if (NILP (bar
->prev
))
2182 /* If the prev pointer is nil, it must be the first in one of
2184 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
2185 /* It's not condemned. Everything's fine. */
2187 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
2188 window
->vertical_scroll_bar
))
2189 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
2191 /* If its prev pointer is nil, it must be at the front of
2192 one or the other! */
2196 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
2198 if (! NILP (bar
->next
))
2199 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
2201 bar
->next
= FRAME_SCROLL_BARS (f
);
2203 XSET (FRAME_SCROLL_BARS (f
), Lisp_Vector
, bar
);
2204 if (! NILP (bar
->next
))
2205 XSET (XSCROLL_BAR (bar
->next
)->prev
, Lisp_Vector
, bar
);
2209 /* Remove all scroll bars on FRAME that haven't been saved since the
2210 last call to `*condemn_scroll_bars_hook'. */
2212 XTjudge_scroll_bars (f
)
2215 Lisp_Object bar
, next
;
2217 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
2219 /* Clear out the condemned list now so we won't try to process any
2220 more events on the hapless scroll bars. */
2221 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
2223 for (; ! NILP (bar
); bar
= next
)
2225 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
2227 x_scroll_bar_remove (b
);
2230 b
->next
= b
->prev
= Qnil
;
2233 /* Now there should be no references to the condemned scroll bars,
2234 and they should get garbage-collected. */
2238 /* Handle an Expose or GraphicsExpose event on a scroll bar.
2240 This may be called from a signal handler, so we have to ignore GC
2243 x_scroll_bar_expose (bar
, event
)
2244 struct scroll_bar
*bar
;
2247 Window w
= SCROLL_BAR_X_WINDOW (bar
);
2248 GC gc
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))->display
.x
->normal_gc
;
2252 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
2254 /* Draw a one-pixel border just inside the edges of the scroll bar. */
2255 XDrawRectangle (x_current_display
, w
, gc
,
2257 /* x, y, width, height */
2258 0, 0, XINT (bar
->width
) - 1, XINT (bar
->height
) - 1);
2260 /* Draw another line to make the extra-thick border on the right. */
2261 XFillRectangle (x_current_display
, w
, gc
,
2263 /* x, y, width, height */
2264 XINT (bar
->width
) - 2, 1, 1, XINT (bar
->height
) - 2);
2269 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
2270 is set to something other than no_event, it is enqueued.
2272 This may be called from a signal handler, so we have to ignore GC
2275 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
2276 struct scroll_bar
*bar
;
2278 struct input_event
*emacs_event
;
2280 if (XGCTYPE (bar
->window
) != Lisp_Window
)
2283 emacs_event
->kind
= scroll_bar_click
;
2284 XSET (emacs_event
->code
, Lisp_Int
, event
->xbutton
.button
- Button1
);
2285 emacs_event
->modifiers
=
2286 (x_x_to_emacs_modifiers (event
->xbutton
.state
)
2287 | (event
->type
== ButtonRelease
2290 emacs_event
->frame_or_window
= bar
->window
;
2291 emacs_event
->timestamp
= event
->xbutton
.time
;
2293 int internal_height
=
2294 VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2296 VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2297 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
2300 if (y
> top_range
) y
= top_range
;
2302 if (y
< XINT (bar
->start
))
2303 emacs_event
->part
= scroll_bar_above_handle
;
2304 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
2305 emacs_event
->part
= scroll_bar_handle
;
2307 emacs_event
->part
= scroll_bar_below_handle
;
2309 /* Just because the user has clicked on the handle doesn't mean
2310 they want to drag it. Lisp code needs to be able to decide
2311 whether or not we're dragging. */
2313 /* If the user has just clicked on the handle, record where they're
2315 if (event
->type
== ButtonPress
2316 && emacs_event
->part
== scroll_bar_handle
)
2317 XSET (bar
->dragging
, Lisp_Int
, y
- XINT (bar
->start
));
2320 /* If the user has released the handle, set it to its final position. */
2321 if (event
->type
== ButtonRelease
2322 && ! NILP (bar
->dragging
))
2324 int new_start
= y
- XINT (bar
->dragging
);
2325 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2327 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2328 bar
->dragging
= Qnil
;
2331 /* Same deal here as the other #if 0. */
2333 /* Clicks on the handle are always reported as occuring at the top of
2335 if (emacs_event
->part
== scroll_bar_handle
)
2336 emacs_event
->x
= bar
->start
;
2338 XSET (emacs_event
->x
, Lisp_Int
, y
);
2340 XSET (emacs_event
->x
, Lisp_Int
, y
);
2343 XSET (emacs_event
->y
, Lisp_Int
, top_range
);
2347 /* Handle some mouse motion while someone is dragging the scroll bar.
2349 This may be called from a signal handler, so we have to ignore GC
2352 x_scroll_bar_note_movement (bar
, event
)
2353 struct scroll_bar
*bar
;
2356 last_mouse_movement_time
= event
->xmotion
.time
;
2359 XSET (last_mouse_scroll_bar
, Lisp_Vector
, bar
);
2361 /* If we're dragging the bar, display it. */
2362 if (! GC_NILP (bar
->dragging
))
2364 /* Where should the handle be now? */
2365 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
2367 if (new_start
!= XINT (bar
->start
))
2369 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
2371 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
2375 /* Call XQueryPointer so we'll get an event the next time the mouse
2376 moves and we can see *still* on the same position. */
2380 XQueryPointer (event
->xmotion
.display
, event
->xmotion
.window
,
2381 (Window
*) &dummy
, (Window
*) &dummy
,
2382 &dummy
, &dummy
, &dummy
, &dummy
,
2383 (unsigned int *) &dummy
);
2387 /* Return information to the user about the current position of the mouse
2388 on the scroll bar. */
2390 x_scroll_bar_report_motion (f
, bar_window
, part
, x
, y
, time
)
2392 Lisp_Object
*bar_window
;
2393 enum scroll_bar_part
*part
;
2395 unsigned long *time
;
2397 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
2399 Window dummy_window
;
2401 unsigned int dummy_mask
;
2405 /* Get the mouse's position relative to the scroll bar window, and
2407 if (! XQueryPointer (x_current_display
,
2408 SCROLL_BAR_X_WINDOW (bar
),
2410 /* Root, child, root x and root y. */
2411 &dummy_window
, &dummy_window
,
2412 &dummy_coord
, &dummy_coord
,
2414 /* Position relative to scroll bar. */
2417 /* Mouse buttons and modifier keys. */
2423 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2425 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2427 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
2429 if (! NILP (bar
->dragging
))
2430 win_y
-= XINT (bar
->dragging
);
2434 if (win_y
> top_range
)
2437 *f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2438 *bar_window
= bar
->window
;
2440 if (! NILP (bar
->dragging
))
2441 *part
= scroll_bar_handle
;
2442 else if (win_y
< XINT (bar
->start
))
2443 *part
= scroll_bar_above_handle
;
2444 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
2445 *part
= scroll_bar_handle
;
2447 *part
= scroll_bar_below_handle
;
2449 XSET (*x
, Lisp_Int
, win_y
);
2450 XSET (*y
, Lisp_Int
, top_range
);
2453 last_mouse_scroll_bar
= Qnil
;
2456 *time
= last_mouse_movement_time
;
2462 /* The screen has been cleared so we may have changed foreground or
2463 background colors, and the scroll bars may need to be redrawn.
2464 Clear out the scroll bars, and ask for expose events, so we can
2467 x_scroll_bar_clear (f
)
2472 for (bar
= FRAME_SCROLL_BARS (f
);
2473 XTYPE (bar
) == Lisp_Vector
;
2474 bar
= XSCROLL_BAR (bar
)->next
)
2475 XClearArea (x_current_display
, SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
2481 /* The main X event-reading loop - XTread_socket. */
2483 /* Timestamp of enter window event. This is only used by XTread_socket,
2484 but we have to put it out here, since static variables within functions
2485 sometimes don't work. */
2486 static Time enter_timestamp
;
2488 /* This holds the state XLookupString needs to implement dead keys
2489 and other tricks known as "compose processing". _X Window System_
2490 says that a portable program can't use this, but Stephen Gildea assures
2491 me that letting the compiler initialize it to zeros will work okay.
2493 This must be defined outside of XTread_socket, for the same reasons
2494 given for enter_timestamp, above. */
2495 static XComposeStatus compose_status
;
2497 /* Communication with window managers. */
2498 Atom Xatom_wm_protocols
;
2500 /* Kinds of protocol things we may receive. */
2501 Atom Xatom_wm_take_focus
;
2502 Atom Xatom_wm_save_yourself
;
2503 Atom Xatom_wm_delete_window
;
2505 /* Other WM communication */
2506 Atom Xatom_wm_configure_denied
; /* When our config request is denied */
2507 Atom Xatom_wm_window_moved
; /* When the WM moves us. */
2509 /* Window manager communication. */
2510 Atom Xatom_wm_change_state
;
2512 /* Record the last 100 characters stored
2513 to help debug the loss-of-chars-during-GC problem. */
2515 short temp_buffer
[100];
2517 /* Read events coming from the X server.
2518 This routine is called by the SIGIO handler.
2519 We return as soon as there are no more events to be read.
2521 Events representing keys are stored in buffer BUFP,
2522 which can hold up to NUMCHARS characters.
2523 We return the number of characters stored into the buffer,
2524 thus pretending to be `read'.
2526 WAITP is nonzero if we should block until input arrives.
2527 EXPECTED is nonzero if the caller knows input is available. */
2530 XTread_socket (sd
, bufp
, numchars
, waitp
, expected
)
2532 register struct input_event
*bufp
;
2533 register int numchars
;
2540 int items_pending
; /* How many items are in the X queue. */
2547 if (interrupt_input_blocked
)
2549 interrupt_input_pending
= 1;
2553 interrupt_input_pending
= 0;
2557 abort (); /* Don't think this happens. */
2560 /* If available, Xlib uses FIOSNBIO to make the socket
2561 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
2562 FIOSNBIO is ignored, and instead of signalling EWOULDBLOCK,
2563 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
2564 fcntl (fileno (stdin
), F_SETFL
, 0);
2565 #endif /* ! defined (FIOSNBIO) */
2569 if (! (fcntl (fileno (stdin
), F_GETFL
, 0) & O_NDELAY
))
2571 extern int read_alarm_should_throw
;
2572 read_alarm_should_throw
= 1;
2573 XPeekEvent (XDISPLAY
&event
);
2574 read_alarm_should_throw
= 0;
2576 #endif /* HAVE_SELECT */
2579 while (XStuffPending () != 0)
2581 XNextEvent (XDISPLAY
&event
);
2589 if (event
.xclient
.message_type
== Xatom_wm_protocols
2590 && event
.xclient
.format
== 32)
2592 if (event
.xclient
.data
.l
[0] == Xatom_wm_take_focus
)
2594 f
= x_window_to_frame (event
.xclient
.window
);
2596 x_focus_on_frame (f
);
2597 /* Not certain about handling scroll bars here */
2599 else if (event
.xclient
.data
.l
[0] == Xatom_wm_save_yourself
)
2601 /* Save state modify the WM_COMMAND property to
2602 something which can reinstate us. This notifies
2603 the session manager, who's looking for such a
2604 PropertyNotify. Can restart processing when
2605 a keyboard or mouse event arrives. */
2610 else if (event
.xclient
.data
.l
[0] == Xatom_wm_delete_window
)
2612 struct frame
*f
= x_window_to_frame (event
.xclient
.window
);
2620 else if (event
.xclient
.message_type
== Xatom_wm_configure_denied
)
2623 else if (event
.xclient
.message_type
== Xatom_wm_window_moved
)
2627 new_x
= event
.xclient
.data
.s
[0];
2628 new_y
= event
.xclient
.data
.s
[1];
2633 #ifdef NEW_SELECTIONS
2634 case SelectionNotify
:
2635 x_handle_selection_notify (&event
);
2639 case SelectionClear
: /* Someone has grabbed ownership. */
2640 #ifdef NEW_SELECTIONS
2642 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
2647 bufp
->kind
= selection_clear_event
;
2648 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
2649 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
2650 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
2657 x_disown_selection (event
.xselectionclear
.window
,
2658 event
.xselectionclear
.selection
,
2659 event
.xselectionclear
.time
);
2663 case SelectionRequest
: /* Someone wants our selection. */
2664 #ifdef NEW_SELECTIONS
2666 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
2671 bufp
->kind
= selection_request_event
;
2672 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
2673 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
2674 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
2675 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
2676 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
2677 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
2684 x_answer_selection_request (event
);
2688 case PropertyNotify
:
2689 #ifdef NEW_SELECTIONS
2690 x_handle_property_notify (&event
);
2692 /* If we're being told about a root window property, then it's
2693 a cut buffer change. */
2694 if (event
.xproperty
.window
== ROOT_WINDOW
)
2695 x_invalidate_cut_buffer_cache (&event
.xproperty
);
2697 /* Otherwise, we're probably handling an incremental
2698 selection transmission. */
2701 /* If we were to do this synchronously, there'd be no worry
2702 about re-selecting. */
2703 x_send_incremental (event
);
2708 case ReparentNotify
:
2709 f
= x_window_to_frame (event
.xreparent
.window
);
2711 f
->display
.x
->parent_desc
= event
.xreparent
.parent
;
2715 f
= x_window_to_frame (event
.xexpose
.window
);
2718 if (f
->async_visible
== 0)
2720 f
->async_visible
= 1;
2721 f
->async_iconified
= 0;
2722 SET_FRAME_GARBAGED (f
);
2726 dumprectangle (x_window_to_frame (event
.xexpose
.window
),
2727 event
.xexpose
.x
, event
.xexpose
.y
,
2728 event
.xexpose
.width
, event
.xexpose
.height
);
2733 struct scroll_bar
*bar
2734 = x_window_to_scroll_bar (event
.xexpose
.window
);
2737 x_scroll_bar_expose (bar
, &event
);
2741 case GraphicsExpose
: /* This occurs when an XCopyArea's
2742 source area was obscured or not
2744 f
= x_window_to_frame (event
.xgraphicsexpose
.drawable
);
2748 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
2749 event
.xgraphicsexpose
.width
,
2750 event
.xgraphicsexpose
.height
);
2754 case NoExpose
: /* This occurs when an XCopyArea's
2755 source area was completely
2758 #else /* ! defined (HAVE_X11) */
2760 if (event
.subwindow
!= 0)
2761 break; /* duplicate event */
2762 f
= x_window_to_frame (event
.window
);
2763 if (event
.window
== f
->display
.x
->icon_desc
)
2766 f
->async_iconified
= 1;
2768 if (event
.window
== FRAME_X_WINDOW (f
))
2770 /* Say must check all windows' needs_exposure flags. */
2771 expose_all_windows
= 1;
2772 f
->display
.x
->needs_exposure
= 1;
2773 f
->async_visible
= 1;
2778 if (event
.subwindow
!= 0)
2779 break; /* duplicate event */
2780 f
= x_window_to_frame (event
.window
);
2781 if (event
.window
== f
->display
.x
->icon_desc
)
2786 /* If window already needs full redraw, ignore this rectangle. */
2787 if (expose_all_windows
&& f
->display
.x
->needs_exposure
)
2789 /* Put the event on the queue of rectangles to redraw. */
2790 if (enqueue_event (&event
, &x_expose_queue
))
2791 /* If it is full, we can't record the rectangle,
2792 so redraw this entire window. */
2794 /* Say must check all windows' needs_exposure flags. */
2795 expose_all_windows
= 1;
2796 f
->display
.x
->needs_exposure
= 1;
2801 /* This should happen only when we are expecting it,
2802 in x_read_exposes. */
2804 #endif /* ! defined (HAVE_X11) */
2808 f
= x_window_to_frame (event
.xunmap
.window
);
2809 if (f
) /* F may no longer exist if
2810 the frame was deleted. */
2812 /* While a frame is unmapped, display generation is
2813 disabled; you don't want to spend time updating a
2814 display that won't ever be seen. */
2815 f
->async_visible
= 0;
2820 f
= x_window_to_frame (event
.xmap
.window
);
2823 f
->async_visible
= 1;
2824 f
->async_iconified
= 0;
2826 /* wait_reading_process_input will notice this and update
2827 the frame's display structures. */
2828 SET_FRAME_GARBAGED (f
);
2832 /* Turn off processing if we become fully obscured. */
2833 case VisibilityNotify
:
2836 #else /* ! defined (HAVE_X11) */
2838 f
= x_window_to_frame (event
.window
);
2839 if (event
.window
== f
->display
.x
->icon_desc
)
2840 f
->async_iconified
= 0;
2841 if (event
.window
== FRAME_X_WINDOW (f
))
2842 f
->async_visible
= 0;
2844 #endif /* ! defined (HAVE_X11) */
2848 f
= x_window_to_frame (event
.xkey
.window
);
2853 char copy_buffer
[80];
2857 |= x_emacs_to_x_modifiers (extra_keyboard_modifiers
);
2858 modifiers
= event
.xkey
.state
;
2860 /* This will have to go some day... */
2862 /* make_lispy_event turns chars into control chars.
2863 Don't do it here because XLookupString is too eager. */
2864 event
.xkey
.state
&= ~ControlMask
;
2866 XLookupString (&event
.xkey
, copy_buffer
, 80, &keysym
,
2869 /* Strip off the vendor-specific keysym bit, and take a shot
2870 at recognizing the codes. HP servers have extra keysyms
2871 that fit into the MiscFunctionKey category. */
2876 if ((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
2877 || keysym
== XK_Delete
2878 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
2879 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < 0xff80 */
2881 /* This recognizes the "extended function keys".
2882 It seems there's no cleaner way. */
2883 || ((unsigned) (keysym
) >= XK_Select
2884 && (unsigned)(keysym
) < XK_KP_Space
)
2886 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
2887 || IsFunctionKey (keysym
)) /* 0xffbe <= x < 0xffe1 */
2889 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
2891 temp_buffer
[temp_index
++] = keysym
;
2892 bufp
->kind
= non_ascii_keystroke
;
2893 XSET (bufp
->code
, Lisp_Int
, (unsigned) keysym
- 0xff00);
2894 XSET (bufp
->frame_or_window
, Lisp_Frame
, f
);
2895 bufp
->modifiers
= x_x_to_emacs_modifiers (modifiers
);
2896 bufp
->timestamp
= event
.xkey
.time
;
2901 else if (numchars
> nbytes
)
2905 for (i
= 0; i
< nbytes
; i
++)
2907 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
2909 temp_buffer
[temp_index
++] = copy_buffer
[i
];
2910 bufp
->kind
= ascii_keystroke
;
2911 XSET (bufp
->code
, Lisp_Int
, copy_buffer
[i
]);
2912 XSET (bufp
->frame_or_window
, Lisp_Frame
, f
);
2913 bufp
->modifiers
= x_x_to_emacs_modifiers (modifiers
);
2914 bufp
->timestamp
= event
.xkey
.time
;
2928 #else /* ! defined (HAVE_X11) */
2931 register char *where_mapping
;
2933 f
= x_window_to_frame (event
.window
);
2934 /* Ignore keys typed on icon windows. */
2935 if (f
!= 0 && event
.window
== f
->display
.x
->icon_desc
)
2937 where_mapping
= XLookupMapping (&event
, &nbytes
);
2938 /* Nasty fix for arrow keys */
2939 if (!nbytes
&& IsCursorKey (event
.detail
& 0xff))
2941 switch (event
.detail
& 0xff)
2943 case KC_CURSOR_LEFT
:
2944 where_mapping
= "\002";
2946 case KC_CURSOR_RIGHT
:
2947 where_mapping
= "\006";
2950 where_mapping
= "\020";
2952 case KC_CURSOR_DOWN
:
2953 where_mapping
= "\016";
2958 if (numchars
- nbytes
> 0)
2962 for (i
= 0; i
< nbytes
; i
++)
2964 bufp
->kind
= ascii_keystroke
;
2965 XSET (bufp
->code
, Lisp_Int
, where_mapping
[i
]);
2966 XSET (bufp
->time
, Lisp_Int
, event
.xkey
.time
);
2967 XSET (bufp
->frame_or_window
, Lisp_Frame
, f
);
2975 #endif /* ! defined (HAVE_X11) */
2979 /* Here's a possible interpretation of the whole
2980 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If you get a
2981 FocusIn event, you have to get a FocusOut event before you
2982 relinquish the focus. If you haven't received a FocusIn event,
2983 then a mere LeaveNotify is enough to free you. */
2986 f
= x_window_to_frame (event
.xcrossing
.window
);
2988 if (event
.xcrossing
.focus
) /* Entered Window */
2990 /* Avoid nasty pop/raise loops. */
2991 if (f
&& (!(f
->auto_raise
)
2993 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
2995 x_new_focus_frame (f
);
2996 enter_timestamp
= event
.xcrossing
.time
;
2999 else if (f
== x_focus_frame
)
3000 x_new_focus_frame (0);
3005 f
= x_window_to_frame (event
.xfocus
.window
);
3006 if (event
.xfocus
.detail
!= NotifyPointer
)
3007 x_focus_event_frame
= f
;
3009 x_new_focus_frame (f
);
3014 f
= x_window_to_frame (event
.xcrossing
.window
);
3016 if (event
.xcrossing
.focus
)
3018 if (! x_focus_event_frame
)
3019 x_new_focus_frame (0);
3021 x_new_focus_frame (f
);
3025 if (f
== x_focus_event_frame
)
3026 x_focus_event_frame
= 0;
3027 if (f
== x_focus_frame
)
3028 x_new_focus_frame (0);
3033 f
= x_window_to_frame (event
.xfocus
.window
);
3034 if (event
.xfocus
.detail
!= NotifyPointer
3035 && f
== x_focus_event_frame
)
3036 x_focus_event_frame
= 0;
3037 if (f
&& f
== x_focus_frame
)
3038 x_new_focus_frame (0);
3041 #else /* ! defined (HAVE_X11) */
3044 if ((event
.detail
& 0xFF) == 1)
3045 break; /* Coming from our own subwindow */
3046 if (event
.subwindow
!= 0)
3047 break; /* Entering our own subwindow. */
3050 f
= x_window_to_frame (event
.window
);
3053 x_new_focus_frame (f
);
3058 if ((event
.detail
& 0xFF) == 1)
3059 break; /* Entering our own subwindow */
3060 if (event
.subwindow
!= 0)
3061 break; /* Leaving our own subwindow. */
3064 if (x_focus_frame
== 0
3065 && x_input_frame
!= 0
3066 && x_input_frame
== x_window_to_frame (event
.window
)
3067 && event
.window
== FRAME_X_WINDOW (x_input_frame
))
3072 frame_unhighlight (f
);
3075 #endif /* ! defined (HAVE_X11) */
3080 f
= x_window_to_frame (event
.xmotion
.window
);
3082 note_mouse_movement (f
, &event
.xmotion
);
3085 struct scroll_bar
*bar
=
3086 x_window_to_scroll_bar (event
.xmotion
.window
);
3089 x_scroll_bar_note_movement (bar
, &event
);
3094 case ConfigureNotify
:
3095 f
= x_window_to_frame (event
.xconfigure
.window
);
3098 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
3099 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
3101 /* Even if the number of character rows and columns has
3102 not changed, the font size may have changed, so we need
3103 to check the pixel dimensions as well. */
3104 if (columns
!= f
->width
3105 || rows
!= f
->height
3106 || event
.xconfigure
.width
!= f
->display
.x
->pixel_width
3107 || event
.xconfigure
.height
!= f
->display
.x
->pixel_height
)
3109 change_frame_size (f
, rows
, columns
, 0, 1);
3110 SET_FRAME_GARBAGED (f
);
3113 if (! event
.xconfigure
.send_event
)
3118 /* Coords are relative to the parent.
3119 Convert them to root-relative. */
3120 XTranslateCoordinates (x_current_display
,
3122 /* From-window, to-window. */
3123 f
->display
.x
->parent_desc
,
3126 /* From-position, to-position. */
3133 event
.xconfigure
.x
= win_x
;
3134 event
.xconfigure
.y
= win_y
;
3137 f
->display
.x
->pixel_width
= event
.xconfigure
.width
;
3138 f
->display
.x
->pixel_height
= event
.xconfigure
.height
;
3139 f
->display
.x
->left_pos
= event
.xconfigure
.x
;
3140 f
->display
.x
->top_pos
= event
.xconfigure
.y
;
3147 /* If we decide we want to generate an event to be seen
3148 by the rest of Emacs, we put it here. */
3149 struct input_event emacs_event
;
3150 emacs_event
.kind
= no_event
;
3152 f
= x_window_to_frame (event
.xbutton
.window
);
3155 if (!x_focus_frame
|| (f
== x_focus_frame
))
3156 construct_mouse_click (&emacs_event
,
3161 struct scroll_bar
*bar
=
3162 x_window_to_scroll_bar (event
.xbutton
.window
);
3165 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
3168 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
3170 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
3178 #else /* ! defined (HAVE_X11) */
3180 case ButtonReleased
:
3181 f
= x_window_to_frame (event
.window
);
3184 if (event
.window
== f
->display
.x
->icon_desc
)
3186 x_make_frame_visible (f
);
3188 if (warp_mouse_on_deiconify
)
3189 XWarpMouse (FRAME_X_WINDOW (f
), 10, 10);
3192 if (event
.window
== FRAME_X_WINDOW (f
))
3198 enqueue_event (&event
, &x_mouse_queue
);
3201 bufp
->kind
= ascii_keystroke
;
3202 bufp
->code
= (char) 'X' & 037; /* C-x */
3203 XSET (bufp
->frame_or_window
, Lisp_Frame
, f
);
3204 XSET (bufp
->time
, Lisp_Int
, event
.xkey
.time
);
3207 bufp
->kind
= ascii_keystroke
;
3208 bufp
->code
= (char) 0; /* C-@ */
3209 XSET (bufp
->frame_or_window
, Lisp_Frame
, f
);
3210 XSET (bufp
->time
, Lisp_Int
, event
.xkey
.time
);
3217 #endif /* ! defined (HAVE_X11) */
3221 case CirculateNotify
:
3223 case CirculateRequest
:
3226 #endif /* ! defined (HAVE_X11) */
3229 /* Someone has changed the keyboard mapping - update the
3231 switch (event
.xmapping
.request
)
3233 case MappingModifier
:
3234 x_find_modifier_meanings ();
3235 /* This is meant to fall through. */
3236 case MappingKeyboard
:
3237 XRefreshKeyboardMapping (&event
.xmapping
);
3248 if (expected
&& ! event_found
)
3250 /* AOJ 880406: if select returns true but XPending doesn't, it means that
3251 there is an EOF condition; in other words, that X has died.
3252 Act as if there had been a hangup. */
3254 int fd
= ConnectionNumber (x_current_display
);
3257 if (0 != select (fd
+ 1, &mask
, (long *) 0, (long *) 0,
3259 && !XStuffPending ())
3260 kill (getpid (), SIGHUP
);
3262 #endif /* ! defined (HAVE_SELECT) */
3266 if (updating_frame
== 0)
3267 x_do_pending_expose ();
3275 /* Read and process only Expose events
3276 until we get an ExposeCopy event; then return.
3277 This is used in insert/delete line.
3278 We assume input is already blocked. */
3284 XKeyPressedEvent event
;
3288 /* while there are more events*/
3289 XMaskEvent (ExposeWindow
| ExposeRegion
| ExposeCopy
, &event
);
3293 if (event
.subwindow
!= 0)
3294 break; /* duplicate event */
3295 f
= x_window_to_frame (event
.window
);
3296 if (event
.window
== f
->display
.x
->icon_desc
)
3301 if (event
.window
== FRAME_X_WINDOW (f
))
3303 expose_all_windows
= 1;
3304 f
->display
.x
->needs_exposure
= 1;
3310 if (event
.subwindow
!= 0)
3311 break; /* duplicate event */
3312 f
= x_window_to_frame (event
.window
);
3313 if (event
.window
== f
->display
.x
->icon_desc
)
3318 /* If window already needs full redraw, ignore this rectangle. */
3319 if (expose_all_windows
&& f
->display
.x
->needs_exposure
)
3321 /* Put the event on the queue of rectangles to redraw. */
3322 if (enqueue_event (&event
, &x_expose_queue
))
3323 /* If it is full, we can't record the rectangle,
3324 so redraw this entire window. */
3326 /* Say must check all windows' needs_exposure flags. */
3327 expose_all_windows
= 1;
3328 f
->display
.x
->needs_exposure
= 1;
3337 #endif /* HAVE_X11 */
3340 /* Drawing the cursor. */
3343 /* Draw a hollow box cursor. Don't change the inside of the box. */
3349 int left
= CHAR_TO_PIXEL_COL (f
, f
->cursor_x
);
3350 int top
= CHAR_TO_PIXEL_ROW (f
, f
->cursor_y
);
3351 int width
= FONT_WIDTH (f
->display
.x
->font
);
3352 int height
= FONT_HEIGHT (f
->display
.x
->font
);
3355 XDrawRectangle (x_current_display
, FRAME_X_WINDOW (f
),
3356 f
->display
.x
->cursor_gc
,
3357 left
, top
, width
- 1, height
- 1);
3358 #else /* ! defined (HAVE_X11) */
3359 XPixSet (FRAME_X_WINDOW (f
),
3360 left
, top
, width
, 1,
3361 f
->display
.x
->cursor_pixel
);
3363 XPixSet (FRAME_X_WINDOW (f
),
3364 left
, top
, 1, height
,
3365 f
->display
.x
->cursor_pixel
);
3367 XPixSet (FRAME_X_WINDOW (f
),
3368 left
+width
-1, top
, 1, height
,
3369 f
->display
.x
->cursor_pixel
);
3371 XPixSet (FRAME_X_WINDOW (f
),
3372 left
, top
+height
-1, width
, 1,
3373 f
->display
.x
->cursor_pixel
);
3374 #endif /* ! defined (HAVE_X11) */
3377 /* Clear the cursor of frame F to background color,
3378 and mark the cursor as not shown.
3379 This is used when the text where the cursor is
3380 is about to be rewritten. */
3388 if (! FRAME_VISIBLE_P (f
)
3389 || f
->phys_cursor_x
< 0)
3393 x_display_cursor (f
, 0);
3394 #else /* ! defined (HAVE_X11) */
3395 XPixSet (FRAME_X_WINDOW (f
),
3396 CHAR_TO_PIXEL_COL (f
, f
->phys_cursor_x
),
3397 CHAR_TO_PIXEL_ROW (f
, f
->phys_cursor_y
),
3398 FONT_WIDTH (f
->display
.x
->font
), FONT_HEIGHT (f
->display
.x
->font
),
3399 f
->display
.x
->background_pixel
);
3400 #endif /* ! defined (HAVE_X11) */
3401 f
->phys_cursor_x
= -1;
3404 /* Redraw the glyph at ROW, COLUMN on frame F, in the style
3405 HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
3409 x_draw_single_glyph (f
, row
, column
, glyph
, highlight
)
3416 CHAR_TO_PIXEL_COL (f
, column
),
3417 CHAR_TO_PIXEL_ROW (f
, row
),
3418 &glyph
, 1, highlight
);
3422 x_display_bar_cursor (f
, on
)
3426 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
3428 /* This is pointless on invisible frames, and dangerous on garbaged
3429 frames; in the latter case, the frame may be in the midst of
3430 changing its size, and curs_x and curs_y may be off the frame. */
3431 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
3434 if (! on
&& f
->phys_cursor_x
< 0)
3437 /* If we're not updating, then we want to use the current frame's
3438 cursor position, not our local idea of where the cursor ought to be. */
3439 if (f
!= updating_frame
)
3441 curs_x
= FRAME_CURSOR_X (f
);
3442 curs_y
= FRAME_CURSOR_Y (f
);
3445 /* If there is anything wrong with the current cursor state, remove it. */
3446 if (f
->phys_cursor_x
>= 0
3448 || f
->phys_cursor_x
!= curs_x
3449 || f
->phys_cursor_y
!= curs_y
3450 || f
->display
.x
->current_cursor
!= bar_cursor
))
3452 /* Erase the cursor by redrawing the character underneath it. */
3453 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
3454 f
->phys_cursor_glyph
,
3455 current_glyphs
->highlight
[f
->phys_cursor_y
]);
3456 f
->phys_cursor_x
= -1;
3459 /* If we now need a cursor in the new place or in the new form, do it so. */
3461 && (f
->phys_cursor_x
< 0
3462 || (f
->display
.x
->current_cursor
!= bar_cursor
)))
3464 f
->phys_cursor_glyph
3465 = ((current_glyphs
->enable
[curs_y
]
3466 && curs_x
< current_glyphs
->used
[curs_y
])
3467 ? current_glyphs
->glyphs
[curs_y
][curs_x
]
3469 XFillRectangle (x_current_display
, FRAME_X_WINDOW (f
),
3470 f
->display
.x
->cursor_gc
,
3471 CHAR_TO_PIXEL_COL (f
, curs_x
),
3472 CHAR_TO_PIXEL_ROW (f
, curs_y
),
3473 1, FONT_HEIGHT (f
->display
.x
->font
));
3475 f
->phys_cursor_x
= curs_x
;
3476 f
->phys_cursor_y
= curs_y
;
3478 f
->display
.x
->current_cursor
= bar_cursor
;
3481 if (updating_frame
!= f
)
3486 /* Turn the displayed cursor of frame F on or off according to ON.
3487 If ON is nonzero, where to put the cursor is specified
3488 by F->cursor_x and F->cursor_y. */
3491 x_display_box_cursor (f
, on
)
3495 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
3497 /* This is pointless on invisible frames, and dangerous on garbaged
3498 frames; in the latter case, the frame may be in the midst of
3499 changing its size, and curs_x and curs_y may be off the frame. */
3500 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
3503 /* If cursor is off and we want it off, return quickly. */
3504 if (!on
&& f
->phys_cursor_x
< 0)
3507 /* If we're not updating, then we want to use the current frame's
3508 cursor position, not our local idea of where the cursor ought to be. */
3509 if (f
!= updating_frame
)
3511 curs_x
= FRAME_CURSOR_X (f
);
3512 curs_y
= FRAME_CURSOR_Y (f
);
3515 /* If cursor is currently being shown and we don't want it to be
3516 or it is in the wrong place,
3517 or we want a hollow box and it's not so, (pout!)
3519 if (f
->phys_cursor_x
>= 0
3521 || f
->phys_cursor_x
!= curs_x
3522 || f
->phys_cursor_y
!= curs_y
3523 || (f
->display
.x
->current_cursor
!= hollow_box_cursor
3524 && (f
!= x_highlight_frame
))))
3526 /* Erase the cursor by redrawing the character underneath it. */
3527 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
3528 f
->phys_cursor_glyph
,
3529 current_glyphs
->highlight
[f
->phys_cursor_y
]);
3530 f
->phys_cursor_x
= -1;
3533 /* If we want to show a cursor,
3534 or we want a box cursor and it's not so,
3535 write it in the right place. */
3537 && (f
->phys_cursor_x
< 0
3538 || (f
->display
.x
->current_cursor
!= filled_box_cursor
3539 && f
== x_highlight_frame
)))
3541 f
->phys_cursor_glyph
3542 = ((current_glyphs
->enable
[curs_y
]
3543 && curs_x
< current_glyphs
->used
[curs_y
])
3544 ? current_glyphs
->glyphs
[curs_y
][curs_x
]
3546 if (f
!= x_highlight_frame
)
3549 f
->display
.x
->current_cursor
= hollow_box_cursor
;
3553 x_draw_single_glyph (f
, curs_y
, curs_x
,
3554 f
->phys_cursor_glyph
, 2);
3555 f
->display
.x
->current_cursor
= filled_box_cursor
;
3558 f
->phys_cursor_x
= curs_x
;
3559 f
->phys_cursor_y
= curs_y
;
3562 if (updating_frame
!= f
)
3566 x_display_cursor (f
, on
)
3570 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
3571 x_display_box_cursor (f
, on
);
3572 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
3573 x_display_bar_cursor (f
, on
);
3575 /* Those are the only two we have implemented! */
3581 /* Refresh bitmap kitchen sink icon for frame F
3582 when we get an expose event for it. */
3588 /* Normally, the window manager handles this function. */
3589 #else /* ! defined (HAVE_X11) */
3592 if (f
->display
.x
->icon_bitmap_flag
)
3593 XBitmapBitsPut (f
->display
.x
->icon_desc
, 0, 0, sink_width
, sink_height
,
3594 sink_bits
, BlackPixel
, WHITE_PIX_DEFAULT
,
3595 icon_bitmap
, GXcopy
, AllPlanes
);
3598 extern struct frame
*selected_frame
;
3599 struct Lisp_String
*str
;
3600 unsigned char *string
;
3603 = XSTRING (XBUFFER (XWINDOW (f
->selected_window
)->buffer
)->name
)->data
;
3605 if (f
->display
.x
->icon_label
!= string
)
3607 f
->display
.x
->icon_label
= string
;
3608 XChangeWindow (f
->display
.x
->icon_desc
,
3609 XQueryWidth (string
, icon_font_info
->id
) + 10,
3610 icon_font_info
->height
+ 10);
3613 XText (f
->display
.x
->icon_desc
, 5, 5, string
,
3614 str
->size
, icon_font_info
->id
,
3615 BLACK_PIX_DEFAULT
, WHITE_PIX_DEFAULT
);
3618 #endif /* ! defined (HAVE_X11) */
3621 /* Make the x-window of frame F use the gnu icon bitmap. */
3630 if (FRAME_X_WINDOW (f
) == 0)
3635 XFreePixmap (x_current_display
, icon_bitmap
);
3638 XCreateBitmapFromData (x_current_display
, FRAME_X_WINDOW (f
),
3639 gnu_bits
, gnu_width
, gnu_height
);
3640 x_wm_set_icon_pixmap (f
, icon_bitmap
);
3641 f
->display
.x
->icon_bitmap_flag
= 1;
3642 #else /* ! defined (HAVE_X11) */
3643 if (f
->display
.x
->icon_desc
)
3645 XClearIconWindow (FRAME_X_WINDOW (f
));
3646 XDestroyWindow (f
->display
.x
->icon_desc
);
3649 icon_window
= XCreateWindow (f
->display
.x
->parent_desc
,
3650 0, 0, sink_width
, sink_height
,
3651 2, WhitePixmap
, (Pixmap
) NULL
);
3653 if (icon_window
== 0)
3656 XSetIconWindow (FRAME_X_WINDOW (f
), icon_window
);
3657 XSelectInput (icon_window
, ExposeWindow
| UnmapWindow
);
3659 f
->display
.x
->icon_desc
= icon_window
;
3660 f
->display
.x
->icon_bitmap_flag
= 1;
3662 if (icon_bitmap
== 0)
3664 = XStoreBitmap (sink_mask_width
, sink_mask_height
, sink_mask_bits
);
3665 #endif /* ! defined (HAVE_X11) */
3671 /* Make the x-window of frame F use a rectangle with text. */
3674 x_text_icon (f
, icon_name
)
3682 char *X_DefaultValue
;
3686 #define WhitePixel 1
3687 #endif /* WhitePixel */
3690 #define BlackPixel 0
3691 #endif /* BlackPixel */
3692 #endif /* HAVE_X11 */
3694 if (FRAME_X_WINDOW (f
) == 0)
3699 f
->display
.x
->icon_label
= icon_name
;
3701 if (! f
->display
.x
->icon_label
)
3702 f
->display
.x
->icon_label
= " *emacs* ";
3705 XSetIconName (x_current_display
, FRAME_X_WINDOW (f
),
3706 (char *) f
->display
.x
->icon_label
);
3709 f
->display
.x
->icon_bitmap_flag
= 0;
3710 x_wm_set_icon_pixmap (f
, 0);
3711 #else /* ! defined (HAVE_X11) */
3712 if (icon_font_info
== 0)
3714 = XGetFont (XGetDefault (XDISPLAY
3715 (char *) XSTRING (Vinvocation_name
)->data
,
3718 if (f
->display
.x
->icon_desc
)
3720 XClearIconWindow (XDISPLAY
FRAME_X_WINDOW (f
));
3721 XDestroyWindow (XDISPLAY f
->display
.x
->icon_desc
);
3725 f
->display
.x
->icon_label
= (unsigned char *) icon_name
;
3727 if (! f
->display
.x
->icon_label
)
3728 f
->display
.x
->icon_label
= XSTRING (f
->name
)->data
;
3730 width
= XStringWidth (f
->display
.x
->icon_label
, icon_font_info
, 0, 0);
3731 icon_window
= XCreateWindow (f
->display
.x
->parent_desc
,
3732 f
->display
.x
->left_pos
,
3733 f
->display
.x
->top_pos
,
3734 width
+ 10, icon_font_info
->height
+ 10,
3735 2, BlackPixmap
, WhitePixmap
);
3737 if (icon_window
== 0)
3740 XSetIconWindow (FRAME_X_WINDOW (f
), icon_window
);
3741 XSelectInput (icon_window
, ExposeWindow
| ExposeRegion
| UnmapWindow
| ButtonPressed
);
3743 f
->display
.x
->icon_desc
= icon_window
;
3744 f
->display
.x
->icon_bitmap_flag
= 0;
3745 f
->display
.x
->icon_label
= 0;
3746 #endif /* ! defined (HAVE_X11) */
3751 /* Handling X errors. */
3753 /* Shut down Emacs in an orderly fashion, because of a SIGPIPE on the
3754 X server's connection, or an error reported via the X protocol. */
3757 x_connection_closed ()
3762 shut_down_emacs (0);
3767 /* An X error handler which prints an error message and then kills
3768 Emacs. This is what's normally installed as Xlib's handler for
3771 x_error_quitter (display
, error
)
3777 /* Note that there is no real way portable across R3/R4 to get the
3778 original error handler. */
3780 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
3781 fprintf (stderr
, "X protocol error: %s on protocol request %d\n",
3782 buf
, error
->request_code
);
3784 /* While we're testing Emacs 19, we'll just dump core whenever we
3785 get an X error, so we can figure out why it happened. */
3788 x_connection_closed ();
3791 /* A handler for X IO errors which prints an error message and then
3792 kills Emacs. This is what is always installed as Xlib's handler
3795 x_io_error_quitter (display
)
3798 fprintf (stderr
, "Connection to X server %s lost.\n",
3799 XDisplayName (DisplayString (display
)));
3801 /* While we're testing Emacs 19, we'll just dump core whenever we
3802 get an X error, so we can figure out why it happened. */
3805 x_connection_closed ();
3808 /* A buffer for storing X error messages. */
3809 static char (*x_caught_error_message
)[200];
3811 /* An X error handler which stores the error message in
3812 x_caught_error_message. This is what's installed when
3813 x_catch_errors is in effect. */
3815 x_error_catcher (display
, error
)
3819 XGetErrorText (display
, error
->error_code
,
3820 *x_caught_error_message
, sizeof (*x_caught_error_message
));
3824 /* Begin trapping X errors.
3826 After calling this function, X protocol errors no longer cause
3827 Emacs to exit; instead, they are recorded in x_cfc_error_message.
3829 Calling x_check_errors signals an Emacs error if an X error has
3830 occurred since the last call to x_catch_errors or x_check_errors.
3832 Calling x_uncatch_errors resumes the normal error handling. */
3834 void x_catch_errors(), x_check_errors (), x_uncatch_errors ();
3839 /* Make sure any errors from previous requests have been dealt with. */
3840 XSync (x_current_display
, False
);
3842 /* Set up the error buffer. */
3843 x_caught_error_message
=
3844 (char (*)[]) xmalloc (sizeof (*x_caught_error_message
));
3845 (*x_caught_error_message
)[0] = '\0';
3847 /* Install our little error handler. */
3848 XHandleError (x_error_catcher
);
3851 /* If any X protocol errors have arrived since the last call to
3852 x_catch_errors or x_check_errors, signal an Emacs error using
3853 sprintf (a buffer, FORMAT, the x error message text) as the text. */
3855 x_check_errors (format
)
3858 /* Make sure to catch any errors incurred so far. */
3859 XSync (x_current_display
, False
);
3861 if ((*x_caught_error_message
)[0])
3865 sprintf (buf
, format
, *x_caught_error_message
);
3866 xfree (x_caught_error_message
);
3868 x_uncatch_errors ();
3876 xfree (x_caught_error_message
);
3877 XHandleError (x_error_quitter
);
3881 static unsigned int x_wire_count
;
3884 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
3889 /* Changing the font of the frame. */
3891 /* Set the font of the x-window specified by frame F
3892 to the font named NEWNAME. This is safe to use
3893 even before F has an actual x-window. */
3897 /* A table of all the fonts we have already loaded. */
3898 static XFontStruct
**x_font_table
;
3900 /* The current capacity of x_font_table. */
3901 static int x_font_table_size
;
3903 /* The number of fonts actually stored in x_font_table.
3904 x_font_table[n] is used and valid iff 0 <= n < n_fonts.
3905 0 <= n_fonts <= x_font_table_size. */
3909 x_new_font (f
, fontname
)
3911 register char *fontname
;
3914 int n_matching_fonts
;
3915 XFontStruct
*font_info
;
3918 /* Get a list of all the fonts that match this name. Once we
3919 have a list of matching fonts, we compare them against the fonts
3920 we already have by comparing font ids. */
3921 font_names
= (char **) XListFontsWithInfo (x_current_display
, fontname
,
3922 1024, &n_matching_fonts
,
3925 /* If the server couldn't find any fonts whose named matched fontname,
3926 return an error code. */
3927 if (n_matching_fonts
== 0)
3930 /* See if we've already loaded a matching font. */
3935 for (i
= 0; i
< n_fonts
; i
++)
3936 for (j
= 0; j
< n_matching_fonts
; j
++)
3937 if (x_font_table
[i
]->fid
== font_info
[j
].fid
)
3940 fontname
= font_names
[j
];
3946 /* If we have, just return it from the table. */
3948 f
->display
.x
->font
= x_font_table
[already_loaded
];
3950 /* Otherwise, load the font and add it to the table. */
3956 /* Try to find a character-cell font in the list. */
3958 /* A laudable goal, but this isn't how to do it. */
3959 for (i
= 0; i
< n_matching_fonts
; i
++)
3960 if (! font_info
[i
].per_char
)
3966 if (i
>= n_matching_fonts
)
3969 fontname
= font_names
[i
];
3971 font
= (XFontStruct
*) XLoadQueryFont (x_current_display
, fontname
);
3975 /* Do we need to create the table? */
3976 if (x_font_table_size
== 0)
3978 x_font_table_size
= 16;
3980 = (XFontStruct
**) xmalloc (x_font_table_size
3981 * sizeof (x_font_table
[0]));
3983 /* Do we need to grow the table? */
3984 else if (n_fonts
>= x_font_table_size
)
3986 x_font_table_size
*= 2;
3988 = (XFontStruct
**) xrealloc (x_font_table
,
3990 * sizeof (x_font_table
[0])));
3993 f
->display
.x
->font
= x_font_table
[n_fonts
++] = font
;
3996 /* Now make the frame display the given font. */
3997 if (FRAME_X_WINDOW (f
) != 0)
3999 XSetFont (x_current_display
, f
->display
.x
->normal_gc
,
4000 f
->display
.x
->font
->fid
);
4001 XSetFont (x_current_display
, f
->display
.x
->reverse_gc
,
4002 f
->display
.x
->font
->fid
);
4003 XSetFont (x_current_display
, f
->display
.x
->cursor_gc
,
4004 f
->display
.x
->font
->fid
);
4006 x_set_window_size (f
, f
->width
, f
->height
);
4010 Lisp_Object lispy_name
= build_string (fontname
);
4013 /* Free the information from XListFontsWithInfo. The data
4014 we actually retain comes from XLoadQueryFont. */
4015 XFreeFontInfo (font_names
, font_info
, n_matching_fonts
);
4020 #else /* ! defined (HAVE_X11) */
4021 x_new_font (f
, newname
)
4023 register char *newname
;
4028 temp
= XGetFont (newname
);
4029 if (temp
== (FONT_TYPE
*) 0)
4032 if (f
->display
.x
->font
)
4033 XLoseFont (f
->display
.x
->font
);
4035 f
->display
.x
->font
= temp
;
4037 if (FRAME_X_WINDOW (f
) != 0)
4038 x_set_window_size (f
, f
->width
, f
->height
);
4042 #endif /* ! defined (HAVE_X11) */
4044 /* X Window sizes and positions. */
4046 x_calc_absolute_position (f
)
4050 if (f
->display
.x
->left_pos
< 0)
4051 f
->display
.x
->left_pos
4052 = x_screen_width
- PIXEL_WIDTH (f
) + f
->display
.x
->left_pos
;
4054 if (f
->display
.x
->top_pos
< 0)
4055 f
->display
.x
->top_pos
4056 = x_screen_height
- PIXEL_HEIGHT (f
) + f
->display
.x
->top_pos
;
4057 #else /* ! defined (HAVE_X11) */
4058 WINDOWINFO_TYPE parentinfo
;
4060 XGetWindowInfo (FRAME_X_WINDOW (f
), &parentinfo
);
4062 if (f
->display
.x
->left_pos
< 0)
4063 f
->display
.x
->left_pos
= parentinfo
.width
+ (f
->display
.x
->left_pos
+ 1)
4064 - PIXEL_WIDTH (f
) - 2 * f
->display
.x
->internal_border_width
;
4066 if (f
->display
.x
->top_pos
< 0)
4067 f
->display
.x
->top_pos
= parentinfo
.height
+ (f
->display
.x
->top_pos
+ 1)
4068 - PIXEL_HEIGHT (f
) - 2 * f
->display
.x
->internal_border_width
;
4069 #endif /* ! defined (HAVE_X11) */
4072 x_set_offset (f
, xoff
, yoff
)
4074 register int xoff
, yoff
;
4076 f
->display
.x
->top_pos
= yoff
;
4077 f
->display
.x
->left_pos
= xoff
;
4078 x_calc_absolute_position (f
);
4081 XMoveWindow (XDISPLAY
FRAME_X_WINDOW (f
),
4082 f
->display
.x
->left_pos
, f
->display
.x
->top_pos
);
4084 x_wm_set_size_hint (f
, 0);
4085 #endif /* ! defined (HAVE_X11) */
4089 /* Call this to change the size of frame F's x-window. */
4091 x_set_window_size (f
, cols
, rows
)
4095 int pixelwidth
, pixelheight
;
4100 check_frame_size (f
, &rows
, &cols
);
4101 f
->display
.x
->vertical_scroll_bar_extra
=
4102 (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4103 ? VERTICAL_SCROLL_BAR_PIXEL_WIDTH (f
)
4105 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
4106 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
4109 x_wm_set_size_hint (f
, 0);
4110 #endif /* ! defined (HAVE_X11) */
4111 XChangeWindowSize (FRAME_X_WINDOW (f
), pixelwidth
, pixelheight
);
4113 /* Now, strictly speaking, we can't be sure that this is accurate,
4114 but the window manager will get around to dealing with the size
4115 change request eventually, and we'll hear how it went when the
4116 ConfigureNotify event gets here.
4118 We could just not bother storing any of this information here,
4119 and let the ConfigureNotify event set everything up, but that
4120 might be kind of confusing to the lisp code, since size changes
4121 wouldn't be reported in the frame parameters until some random
4122 point in the future when the ConfigureNotify event arrives. */
4123 change_frame_size (f
, rows
, cols
, 0, 0);
4124 PIXEL_WIDTH (f
) = pixelwidth
;
4125 PIXEL_HEIGHT (f
) = pixelheight
;
4127 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
4128 receive in the ConfigureNotify event; if we get what we asked
4129 for, then the event won't cause the screen to become garbaged, so
4130 we have to make sure to do it here. */
4131 SET_FRAME_GARBAGED (f
);
4138 x_set_resize_hint (f
)
4141 XSetResizeHint (FRAME_X_WINDOW (f
),
4142 2 * f
->display
.x
->internal_border_width
,
4143 2 * f
->display
.x
->internal_border_width
,
4144 FONT_WIDTH (f
->display
.x
->font
),
4145 FONT_HEIGHT (f
->display
.x
->font
));
4147 #endif /* HAVE_X11 */
4149 /* Mouse warping, focus shifting, raising and lowering. */
4151 x_set_mouse_position (f
, x
, y
)
4159 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->display
.x
->font
) / 2;
4160 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + FONT_HEIGHT (f
->display
.x
->font
) / 2;
4162 if (pix_x
< 0) pix_x
= 0;
4163 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
4165 if (pix_y
< 0) pix_y
= 0;
4166 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
4170 XWarpMousePointer (FRAME_X_WINDOW (f
), pix_x
, pix_y
);
4175 x_focus_on_frame (f
)
4180 /* I don't think that the ICCCM allows programs to do things like this
4181 without the interaction of the window manager. Whatever you end up
4182 doing with this code, do it to x_unfocus_frame too. */
4183 XSetInputFocus (x_current_display
, FRAME_X_WINDOW (f
),
4184 RevertToPointerRoot
, CurrentTime
);
4192 /* Look at the remarks in x_focus_on_frame. */
4193 if (x_focus_frame
== f
)
4194 XSetInputFocus (x_current_display
, PointerRoot
,
4195 RevertToPointerRoot
, CurrentTime
);
4199 #endif /* ! defined (HAVE_X11) */
4201 /* Raise frame F. */
4206 if (f
->async_visible
)
4209 XRaiseWindow (XDISPLAY
FRAME_X_WINDOW (f
));
4215 /* Lower frame F. */
4220 if (f
->async_visible
)
4223 XLowerWindow (XDISPLAY
FRAME_X_WINDOW (f
));
4230 XTframe_raise_lower (f
, raise
)
4241 /* Change from withdrawn state to mapped state. */
4243 x_make_frame_visible (f
)
4250 if (! FRAME_VISIBLE_P (f
))
4253 if (! EQ (Vx_no_window_manager
, Qt
))
4254 x_wm_set_window_state (f
, NormalState
);
4256 XMapWindow (XDISPLAY
FRAME_X_WINDOW (f
));
4257 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4258 XMapSubwindows (x_current_display
, FRAME_X_WINDOW (f
));
4259 #else /* ! defined (HAVE_X11) */
4260 XMapWindow (XDISPLAY
FRAME_X_WINDOW (f
));
4261 if (f
->display
.x
->icon_desc
!= 0)
4262 XUnmapWindow (f
->display
.x
->icon_desc
);
4264 /* Handled by the MapNotify event for X11 */
4265 f
->async_visible
= 1;
4266 f
->async_iconified
= 0;
4268 /* NOTE: this may cause problems for the first frame. */
4270 #endif /* ! defined (HAVE_X11) */
4278 /* Change from mapped state to withdrawn state. */
4280 x_make_frame_invisible (f
)
4285 if (! f
->async_visible
)
4292 if (! XWithdrawWindow (x_current_display
, FRAME_X_WINDOW (f
),
4293 DefaultScreen (x_current_display
)))
4295 UNBLOCK_INPUT_RESIGNAL
;
4296 error ("can't notify window manager of window withdrawl");
4299 #else /* ! defined (HAVE_X11R4) */
4302 /* Tell the window manager what we're going to do. */
4303 if (! EQ (Vx_no_window_manager
, Qt
))
4307 unmap
.xunmap
.type
= UnmapNotify
;
4308 unmap
.xunmap
.window
= FRAME_X_WINDOW (f
);
4309 unmap
.xunmap
.event
= DefaultRootWindow (x_current_display
);
4310 unmap
.xunmap
.from_configure
= False
;
4311 if (! XSendEvent (x_current_display
,
4312 DefaultRootWindow (x_current_display
),
4314 SubstructureRedirectMask
|SubstructureNotifyMask
,
4317 UNBLOCK_INPUT_RESIGNAL
;
4318 error ("can't notify window manager of withdrawal");
4322 /* Unmap the window ourselves. Cheeky! */
4323 XUnmapWindow (x_current_display
, FRAME_X_WINDOW (f
));
4325 #else /* ! defined (HAVE_X11) */
4327 XUnmapWindow (FRAME_X_WINDOW (f
));
4328 f
->async_visible
= 0; /* Handled by the UnMap event for X11 */
4329 if (f
->display
.x
->icon_desc
!= 0)
4330 XUnmapWindow (f
->display
.x
->icon_desc
);
4332 #endif /* ! defined (HAVE_X11) */
4333 #endif /* ! defined (HAVE_X11R4) */
4339 /* Change window state from mapped to iconified. */
4346 if (f
->async_iconified
)
4352 /* Since we don't know which revision of X we're running, we'll use both
4353 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
4355 /* X11R4: send a ClientMessage to the window manager using the
4356 WM_CHANGE_STATE type. */
4360 message
.xclient
.window
= FRAME_X_WINDOW (f
);
4361 message
.xclient
.type
= ClientMessage
;
4362 message
.xclient
.message_type
= Xatom_wm_change_state
;
4363 message
.xclient
.format
= 32;
4364 message
.xclient
.data
.l
[0] = IconicState
;
4366 if (! XSendEvent (x_current_display
,
4367 DefaultRootWindow (x_current_display
),
4369 SubstructureRedirectMask
| SubstructureNotifyMask
,
4372 UNBLOCK_INPUT_RESIGNAL
;
4373 error ("Can't notify window manager of iconification.");
4377 /* X11R3: set the initial_state field of the window manager hints to
4379 x_wm_set_window_state (f
, IconicState
);
4381 f
->async_iconified
= 1;
4382 #else /* ! defined (HAVE_X11) */
4383 XUnmapWindow (XDISPLAY
FRAME_X_WINDOW (f
));
4385 f
->async_visible
= 0; /* Handled in the UnMap event for X11. */
4386 if (f
->display
.x
->icon_desc
!= 0)
4388 XMapWindow (XDISPLAY f
->display
.x
->icon_desc
);
4391 #endif /* ! defined (HAVE_X11) */
4397 /* Destroy the X window of frame F. */
4399 x_destroy_window (f
)
4404 if (f
->display
.x
->icon_desc
!= 0)
4405 XDestroyWindow (XDISPLAY f
->display
.x
->icon_desc
);
4406 XDestroyWindow (XDISPLAY f
->display
.x
->window_desc
);
4407 free_frame_faces (f
);
4410 xfree (f
->display
.x
);
4412 if (f
== x_focus_frame
)
4414 if (f
== x_highlight_frame
)
4415 x_highlight_frame
= 0;
4420 /* Manage event queues for X10. */
4424 /* Manage event queues.
4426 This code is only used by the X10 support.
4428 We cannot leave events in the X queue and get them when we are ready
4429 because X does not provide a subroutine to get only a certain kind
4430 of event but not block if there are no queued events of that kind.
4432 Therefore, we must examine events as they come in and copy events
4433 of certain kinds into our private queues.
4435 All ExposeRegion events are put in x_expose_queue.
4436 All ButtonPressed and ButtonReleased events are put in x_mouse_queue. */
4439 /* Write the event *P_XREP into the event queue *QUEUE.
4440 If the queue is full, do nothing, but return nonzero. */
4443 enqueue_event (p_xrep
, queue
)
4444 register XEvent
*p_xrep
;
4445 register struct event_queue
*queue
;
4447 int newindex
= queue
->windex
+ 1;
4448 if (newindex
== EVENT_BUFFER_SIZE
)
4450 if (newindex
== queue
->rindex
)
4452 queue
->xrep
[queue
->windex
] = *p_xrep
;
4453 queue
->windex
= newindex
;
4457 /* Fetch the next event from queue *QUEUE and store it in *P_XREP.
4458 If *QUEUE is empty, do nothing and return 0. */
4461 dequeue_event (p_xrep
, queue
)
4462 register XEvent
*p_xrep
;
4463 register struct event_queue
*queue
;
4465 if (queue
->windex
== queue
->rindex
)
4467 *p_xrep
= queue
->xrep
[queue
->rindex
++];
4468 if (queue
->rindex
== EVENT_BUFFER_SIZE
)
4473 /* Return the number of events buffered in *QUEUE. */
4476 queue_event_count (queue
)
4477 register struct event_queue
*queue
;
4479 int tem
= queue
->windex
- queue
->rindex
;
4482 return EVENT_BUFFER_SIZE
+ tem
;
4485 /* Return nonzero if mouse input is pending. */
4488 mouse_event_pending_p ()
4490 return queue_event_count (&x_mouse_queue
);
4492 #endif /* HAVE_X11 */
4494 /* Setting window manager hints. */
4498 x_wm_set_size_hint (f
, prompting
)
4502 XSizeHints size_hints
;
4503 Window window
= FRAME_X_WINDOW (f
);
4505 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
4507 flexlines
= f
->height
;
4509 size_hints
.x
= f
->display
.x
->left_pos
;
4510 size_hints
.y
= f
->display
.x
->top_pos
;
4511 size_hints
.height
= PIXEL_HEIGHT (f
);
4512 size_hints
.width
= PIXEL_WIDTH (f
);
4513 size_hints
.width_inc
= FONT_WIDTH (f
->display
.x
->font
);
4514 size_hints
.height_inc
= FONT_HEIGHT (f
->display
.x
->font
);
4516 size_hints
.max_width
= x_screen_width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
4517 size_hints
.max_height
= x_screen_height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
4520 int base_width
, base_height
;
4522 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
4523 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
4526 int min_rows
= 0, min_cols
= 0;
4527 check_frame_size (f
, &min_rows
, &min_cols
);
4529 /* The window manager uses the base width hints to calculate the
4530 current number of rows and columns in the frame while
4531 resizing; min_width and min_height aren't useful for this
4532 purpose, since they might not give the dimensions for a
4533 zero-row, zero-column frame.
4535 We use the base_width and base_height members if we have
4536 them; otherwise, we set the min_width and min_height members
4537 to the size for a zero x zero frame. */
4540 size_hints
.flags
|= PBaseSize
;
4541 size_hints
.base_width
= base_width
;
4542 size_hints
.base_height
= base_height
;
4543 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
4544 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
4546 size_hints
.min_width
= base_width
;
4547 size_hints
.min_height
= base_height
;
4554 size_hints
.flags
|= prompting
;
4557 XSizeHints hints
; /* Sometimes I hate X Windows... */
4559 XGetNormalHints (x_current_display
, window
, &hints
);
4560 if (hints
.flags
& PSize
)
4561 size_hints
.flags
|= PSize
;
4562 if (hints
.flags
& PPosition
)
4563 size_hints
.flags
|= PPosition
;
4564 if (hints
.flags
& USPosition
)
4565 size_hints
.flags
|= USPosition
;
4566 if (hints
.flags
& USSize
)
4567 size_hints
.flags
|= USSize
;
4571 XSetWMNormalHints (x_current_display
, window
, &size_hints
);
4573 XSetNormalHints (x_current_display
, window
, &size_hints
);
4577 /* Used for IconicState or NormalState */
4578 x_wm_set_window_state (f
, state
)
4582 Window window
= FRAME_X_WINDOW (f
);
4584 f
->display
.x
->wm_hints
.flags
|= StateHint
;
4585 f
->display
.x
->wm_hints
.initial_state
= state
;
4587 XSetWMHints (x_current_display
, window
, &f
->display
.x
->wm_hints
);
4590 x_wm_set_icon_pixmap (f
, icon_pixmap
)
4594 Window window
= FRAME_X_WINDOW (f
);
4598 f
->display
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
4599 f
->display
.x
->wm_hints
.flags
|= IconPixmapHint
;
4602 f
->display
.x
->wm_hints
.flags
&= ~IconPixmapHint
;
4604 XSetWMHints (x_current_display
, window
, &f
->display
.x
->wm_hints
);
4607 x_wm_set_icon_position (f
, icon_x
, icon_y
)
4611 Window window
= FRAME_X_WINDOW (f
);
4613 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
4614 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
4615 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
4617 XSetWMHints (x_current_display
, window
, &f
->display
.x
->wm_hints
);
4621 /* Initialization. */
4624 x_term_init (display_name
)
4630 extern int old_fcntl_owner
;
4631 #endif /* ! defined (F_SETOWN) */
4633 x_focus_frame
= x_highlight_frame
= 0;
4635 x_current_display
= XOpenDisplay (display_name
);
4636 if (x_current_display
== 0)
4637 fatal ("X server %s not responding; check the DISPLAY environment variable or use \"-d\"\n",
4642 int hostname_size
= 256;
4644 hostname
= (char *) xmalloc (hostname_size
);
4647 XSetAfterFunction (x_current_display
, x_trace_wire
);
4650 /* Try to get the host name; if the buffer is too short, try
4651 again. Apparently, the only indication gethostname gives of
4652 whether the buffer was large enough is the presence or absence
4653 of a '\0' in the string. Eech. */
4656 gethostname (hostname
, hostname_size
- 1);
4657 hostname
[hostname_size
- 1] = '\0';
4659 /* Was the buffer large enough for gethostname to store the '\0'? */
4660 if (strlen (hostname
) < hostname_size
- 1)
4663 hostname_size
<<= 1;
4664 hostname
= (char *) xrealloc (hostname
, hostname_size
);
4666 x_id_name
= (char *) xmalloc (XSTRING (Vinvocation_name
)->size
4669 sprintf (x_id_name
, "%s@%s", XSTRING (Vinvocation_name
)->data
, hostname
);
4672 /* Figure out which modifier bits mean what. */
4673 x_find_modifier_meanings ();
4675 /* Get the scroll bar cursor. */
4676 x_vertical_scroll_bar_cursor
4677 = XCreateFontCursor (x_current_display
, XC_sb_v_double_arrow
);
4680 /* Watch for PropertyNotify events on the root window; we use them
4681 to figure out when to invalidate our cache of the cut buffers. */
4682 x_watch_cut_buffer_cache ();
4685 if (ConnectionNumber (x_current_display
) != 0)
4687 dup2 (ConnectionNumber (x_current_display
), 0);
4689 #ifndef SYSV_STREAMS
4690 /* Streams somehow keeps track of which descriptor number
4691 is being used to talk to X. So it is not safe to substitute
4692 descriptor 0. But it is safe to make descriptor 0 a copy of it. */
4693 close (ConnectionNumber (x_current_display
));
4694 ConnectionNumber (x_current_display
) = 0; /* Looks a little strange?
4695 * check the def of the macro;
4696 * it is a genuine lvalue */
4697 #endif /* SYSV_STREAMS */
4700 #endif /* ! defined (HAVE_X11) */
4703 old_fcntl_owner
= fcntl (0, F_GETOWN
, 0);
4704 #ifdef F_SETOWN_SOCK_NEG
4705 fcntl (0, F_SETOWN
, -getpid ()); /* stdin is a socket here */
4706 #else /* ! defined (F_SETOWN_SOCK_NEG) */
4707 fcntl (0, F_SETOWN
, getpid ());
4708 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
4709 #endif /* ! defined (F_SETOWN) */
4713 #endif /* ! defined (SIGIO) */
4715 /* Must use interrupt input because we cannot otherwise
4716 arrange for C-g to be noticed immediately.
4717 We cannot connect it to SIGINT. */
4718 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
4720 expose_all_windows
= 0;
4722 clear_frame_hook
= XTclear_frame
;
4723 clear_end_of_line_hook
= XTclear_end_of_line
;
4724 ins_del_lines_hook
= XTins_del_lines
;
4725 change_line_highlight_hook
= XTchange_line_highlight
;
4726 insert_glyphs_hook
= XTinsert_glyphs
;
4727 write_glyphs_hook
= XTwrite_glyphs
;
4728 delete_glyphs_hook
= XTdelete_glyphs
;
4729 ring_bell_hook
= XTring_bell
;
4730 reset_terminal_modes_hook
= XTreset_terminal_modes
;
4731 set_terminal_modes_hook
= XTset_terminal_modes
;
4732 update_begin_hook
= XTupdate_begin
;
4733 update_end_hook
= XTupdate_end
;
4734 set_terminal_window_hook
= XTset_terminal_window
;
4735 read_socket_hook
= XTread_socket
;
4736 cursor_to_hook
= XTcursor_to
;
4737 reassert_line_highlight_hook
= XTreassert_line_highlight
;
4738 mouse_position_hook
= XTmouse_position
;
4739 frame_rehighlight_hook
= XTframe_rehighlight
;
4740 frame_raise_lower_hook
= XTframe_raise_lower
;
4741 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
4742 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
4743 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
4744 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
4746 scroll_region_ok
= 1; /* we'll scroll partial frames */
4747 char_ins_del_ok
= 0; /* just as fast to write the line */
4748 line_ins_del_ok
= 1; /* we'll just blt 'em */
4749 fast_clear_end_of_line
= 1; /* X does this well */
4750 memory_below_frame
= 0; /* we don't remember what scrolls
4754 /* Note that there is no real way portable across R3/R4 to get the
4755 original error handler. */
4756 XHandleError (x_error_quitter
);
4757 XHandleIOError (x_io_error_quitter
);
4759 /* Disable Window Change signals; they are handled by X events. */
4761 signal (SIGWINCH
, SIG_DFL
);
4762 #endif /* ! defined (SIGWINCH) */
4764 signal (SIGPIPE
, x_connection_closed
);
4770 staticpro (&last_mouse_scroll_bar
);
4772 #endif /* ! defined (HAVE_X11) */
4773 #endif /* ! defined (HAVE_X_WINDOWS) */