1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
23 /* Xt features made by Fred Pierresteguy. */
27 /* On 4.3 these lose if they come after xterm.h. */
28 /* Putting these at the beginning seems to be standard for other .c files. */
36 #include "blockinput.h"
38 /* Need syssignal.h for various externs and definitions that may be required
39 by some configurations for calls to signal later in this source file. */
40 #include "syssignal.h"
42 /* This may include sys/types.h, and that somehow loses
43 if this is not done before the other system files. */
45 #include <X11/cursorfont.h>
47 /* Load sys/types.h if not already loaded.
48 In some systems loading it twice is suicidal. */
50 #include <sys/types.h>
54 #include <sys/ioctl.h>
55 #endif /* ! defined (BSD_SYSTEM) */
60 #ifndef INCLUDED_FCNTL
67 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
68 /* #include <sys/param.h> */
74 #include "dispextern.h"
76 #include "termhooks.h"
84 #include "intervals.h"
90 #include <X11/Shell.h>
93 #ifdef HAVE_SYS_TIME_H
105 extern int xlwmenu_window_p
P_ ((Widget w
, Window window
));
106 extern void xlwmenu_redisplay
P_ ((Widget
));
109 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
111 extern void free_frame_menubar
P_ ((struct frame
*));
112 extern struct frame
*x_menubar_window_to_frame
P_ ((struct x_display_info
*,
117 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
119 extern void _XEditResCheckMessages ();
120 #endif /* not NO_EDITRES */
122 /* Include toolkit specific headers for the scroll bar widget. */
124 #ifdef USE_TOOLKIT_SCROLL_BARS
125 #if defined USE_MOTIF
126 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
127 #include <Xm/ScrollBar.h>
128 #else /* !USE_MOTIF i.e. use Xaw */
131 #include <X11/Xaw3d/Simple.h>
132 #include <X11/Xaw3d/Scrollbar.h>
133 #include <X11/Xaw3d/ThreeD.h>
134 #else /* !HAVE_XAW3D */
135 #include <X11/Xaw/Simple.h>
136 #include <X11/Xaw/Scrollbar.h>
137 #endif /* !HAVE_XAW3D */
139 #define XtNpickTop "pickTop"
140 #endif /* !XtNpickTop */
141 #endif /* !USE_MOTIF */
142 #endif /* USE_TOOLKIT_SCROLL_BARS */
144 #endif /* USE_X_TOOLKIT */
146 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
147 #define x_any_window_to_frame x_window_to_frame
148 #define x_top_window_to_frame x_window_to_frame
153 #ifndef XtNinitialState
154 #define XtNinitialState "initialState"
158 #define abs(x) ((x) < 0 ? -(x) : (x))
160 /* Default to using XIM if available. */
164 int use_xim
= 0; /* configure --without-xim */
169 /* Non-nil means Emacs uses toolkit scroll bars. */
171 Lisp_Object Vx_toolkit_scroll_bars
;
173 /* Non-zero means that a HELP_EVENT has been generated since Emacs
176 static int any_help_event_p
;
178 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
179 static Lisp_Object last_window
;
181 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
183 int x_use_underline_position_properties
;
185 /* Non-zero means to draw the underline at the same place as the descent line. */
187 int x_underline_at_descent_line
;
189 /* This is a chain of structures for all the X displays currently in
192 struct x_display_info
*x_display_list
;
194 /* This is a list of cons cells, each of the form (NAME
195 . FONT-LIST-CACHE), one for each element of x_display_list and in
196 the same order. NAME is the name of the frame. FONT-LIST-CACHE
197 records previous values returned by x-list-fonts. */
199 Lisp_Object x_display_name_list
;
201 /* Frame being updated by update_frame. This is declared in term.c.
202 This is set by update_begin and looked at by all the XT functions.
203 It is zero while not inside an update. In that case, the XT
204 functions assume that `selected_frame' is the frame to apply to. */
206 extern struct frame
*updating_frame
;
208 /* This is a frame waiting to be auto-raised, within XTread_socket. */
210 struct frame
*pending_autoraise_frame
;
213 /* The application context for Xt use. */
214 XtAppContext Xt_app_con
;
215 static String Xt_default_resources
[] = {0};
216 #endif /* USE_X_TOOLKIT */
218 /* Non-zero means user is interacting with a toolkit scroll bar. */
220 static int toolkit_scroll_bar_interaction
;
222 /* Non-zero means to not move point as a result of clicking on a
223 frame to focus it (when focus-follows-mouse is nil). */
225 int x_mouse_click_focus_ignore_position
;
227 /* Non-zero timeout value means ignore next mouse click if it arrives
228 before that timeout elapses (i.e. as part of the same sequence of
229 events resulting from clicking on a frame to select it). */
231 static unsigned long ignore_next_mouse_click_timeout
;
235 Formerly, we used PointerMotionHintMask (in standard_event_mask)
236 so that we would have to call XQueryPointer after each MotionNotify
237 event to ask for another such event. However, this made mouse tracking
238 slow, and there was a bug that made it eventually stop.
240 Simply asking for MotionNotify all the time seems to work better.
242 In order to avoid asking for motion events and then throwing most
243 of them away or busy-polling the server for mouse positions, we ask
244 the server for pointer motion hints. This means that we get only
245 one event per group of mouse movements. "Groups" are delimited by
246 other kinds of events (focus changes and button clicks, for
247 example), or by XQueryPointer calls; when one of these happens, we
248 get another MotionNotify event the next time the mouse moves. This
249 is at least as efficient as getting motion events when mouse
250 tracking is on, and I suspect only negligibly worse when tracking
253 /* Where the mouse was last time we reported a mouse event. */
255 static XRectangle last_mouse_glyph
;
256 static FRAME_PTR last_mouse_glyph_frame
;
257 static Lisp_Object last_mouse_press_frame
;
259 /* The scroll bar in which the last X motion event occurred.
261 If the last X motion event occurred in a scroll bar, we set this so
262 XTmouse_position can know whether to report a scroll bar motion or
265 If the last X motion event didn't occur in a scroll bar, we set
266 this to Qnil, to tell XTmouse_position to return an ordinary motion
269 static Lisp_Object last_mouse_scroll_bar
;
271 /* This is a hack. We would really prefer that XTmouse_position would
272 return the time associated with the position it returns, but there
273 doesn't seem to be any way to wrest the time-stamp from the server
274 along with the position query. So, we just keep track of the time
275 of the last movement we received, and return that in hopes that
276 it's somewhat accurate. */
278 static Time last_mouse_movement_time
;
280 /* Time for last user interaction as returned in X events. */
282 static Time last_user_time
;
284 /* Incremented by XTread_socket whenever it really tries to read
288 static int volatile input_signal_count
;
290 static int input_signal_count
;
293 /* Used locally within XTread_socket. */
295 static int x_noop_count
;
297 /* Initial values of argv and argc. */
299 extern char **initial_argv
;
300 extern int initial_argc
;
302 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
304 /* Tells if a window manager is present or not. */
306 extern Lisp_Object Vx_no_window_manager
;
308 extern Lisp_Object Qeql
;
312 /* A mask of extra modifier bits to put into every keyboard char. */
314 extern EMACS_INT extra_keyboard_modifiers
;
316 /* The keysyms to use for the various modifiers. */
318 Lisp_Object Vx_alt_keysym
, Vx_hyper_keysym
, Vx_meta_keysym
, Vx_super_keysym
;
319 Lisp_Object Vx_keysym_table
;
320 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
322 static Lisp_Object Qvendor_specific_keysyms
;
323 static Lisp_Object Qlatin_1
;
325 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
326 extern int x_bitmap_mask
P_ ((FRAME_PTR
, int));
328 static int x_alloc_nearest_color_1
P_ ((Display
*, Colormap
, XColor
*));
329 static void x_set_window_size_1
P_ ((struct frame
*, int, int, int));
330 static const XColor
*x_color_cells
P_ ((Display
*, int *));
331 static void x_update_window_end
P_ ((struct window
*, int, int));
333 static int x_io_error_quitter
P_ ((Display
*));
334 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
335 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
336 static void x_update_end
P_ ((struct frame
*));
337 static void XTframe_up_to_date
P_ ((struct frame
*));
338 static void XTset_terminal_modes
P_ ((void));
339 static void XTreset_terminal_modes
P_ ((void));
340 static void x_clear_frame
P_ ((void));
341 static void frame_highlight
P_ ((struct frame
*));
342 static void frame_unhighlight
P_ ((struct frame
*));
343 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
344 static void x_focus_changed
P_ ((int, int, struct x_display_info
*,
345 struct frame
*, struct input_event
*));
346 static void x_detect_focus_change
P_ ((struct x_display_info
*,
347 XEvent
*, struct input_event
*));
348 static void XTframe_rehighlight
P_ ((struct frame
*));
349 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
350 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
351 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
352 enum text_cursor_kinds
));
354 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, GC
));
355 static void x_flush
P_ ((struct frame
*f
));
356 static void x_update_begin
P_ ((struct frame
*));
357 static void x_update_window_begin
P_ ((struct window
*));
358 static void x_after_update_window_line
P_ ((struct glyph_row
*));
359 static struct scroll_bar
*x_window_to_scroll_bar
P_ ((Display
*, Window
));
360 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
361 enum scroll_bar_part
*,
362 Lisp_Object
*, Lisp_Object
*,
364 static void x_check_fullscreen
P_ ((struct frame
*));
365 static void x_check_expected_move
P_ ((struct frame
*, int, int));
366 static void x_sync_with_move
P_ ((struct frame
*, int, int, int));
367 static int handle_one_xevent
P_ ((struct x_display_info
*, XEvent
*,
368 int *, struct input_event
*));
369 static SIGTYPE x_connection_closed
P_ ((Display
*, char *)) NO_RETURN
;
372 /* Flush display of frame F, or of all frames if F is null. */
381 Lisp_Object rest
, frame
;
382 FOR_EACH_FRAME (rest
, frame
)
383 x_flush (XFRAME (frame
));
385 else if (FRAME_X_P (f
))
386 XFlush (FRAME_X_DISPLAY (f
));
391 /* Remove calls to XFlush by defining XFlush to an empty replacement.
392 Calls to XFlush should be unnecessary because the X output buffer
393 is flushed automatically as needed by calls to XPending,
394 XNextEvent, or XWindowEvent according to the XFlush man page.
395 XTread_socket calls XPending. Removing XFlush improves
398 #define XFlush(DISPLAY) (void) 0
401 /***********************************************************************
403 ***********************************************************************/
407 /* This is a function useful for recording debugging information about
408 the sequence of occurrences in this file. */
416 struct record event_record
[100];
418 int event_record_index
;
420 record_event (locus
, type
)
424 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
425 event_record_index
= 0;
427 event_record
[event_record_index
].locus
= locus
;
428 event_record
[event_record_index
].type
= type
;
429 event_record_index
++;
436 /* Return the struct x_display_info corresponding to DPY. */
438 struct x_display_info
*
439 x_display_info_for_display (dpy
)
442 struct x_display_info
*dpyinfo
;
444 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
445 if (dpyinfo
->display
== dpy
)
453 /***********************************************************************
454 Starting and ending an update
455 ***********************************************************************/
457 /* Start an update of frame F. This function is installed as a hook
458 for update_begin, i.e. it is called when update_begin is called.
459 This function is called prior to calls to x_update_window_begin for
460 each window being updated. Currently, there is nothing to do here
461 because all interesting stuff is done on a window basis. */
471 /* Start update of window W. Set the global variable updated_window
472 to the window being updated and set output_cursor to the cursor
476 x_update_window_begin (w
)
479 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
480 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
483 set_output_cursor (&w
->cursor
);
487 if (f
== display_info
->mouse_face_mouse_frame
)
489 /* Don't do highlighting for mouse motion during the update. */
490 display_info
->mouse_face_defer
= 1;
492 /* If F needs to be redrawn, simply forget about any prior mouse
494 if (FRAME_GARBAGED_P (f
))
495 display_info
->mouse_face_window
= Qnil
;
497 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
498 their mouse_face_p flag set, which means that they are always
499 unequal to rows in a desired matrix which never have that
500 flag set. So, rows containing mouse-face glyphs are never
501 scrolled, and we don't have to switch the mouse highlight off
502 here to prevent it from being scrolled. */
504 /* Can we tell that this update does not affect the window
505 where the mouse highlight is? If so, no need to turn off.
506 Likewise, don't do anything if the frame is garbaged;
507 in that case, the frame's current matrix that we would use
508 is all wrong, and we will redisplay that line anyway. */
509 if (!NILP (display_info
->mouse_face_window
)
510 && w
== XWINDOW (display_info
->mouse_face_window
))
514 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
515 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
518 if (i
< w
->desired_matrix
->nrows
)
519 clear_mouse_face (display_info
);
528 /* Draw a vertical window border from (x,y0) to (x,y1) */
531 x_draw_vertical_window_border (w
, x
, y0
, y1
)
535 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
538 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
540 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
543 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
544 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
547 /* End update of window W (which is equal to updated_window).
549 Draw vertical borders between horizontally adjacent windows, and
550 display W's cursor if CURSOR_ON_P is non-zero.
552 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
553 glyphs in mouse-face were overwritten. In that case we have to
554 make sure that the mouse-highlight is properly redrawn.
556 W may be a menu bar pseudo-window in case we don't have X toolkit
557 support. Such windows don't have a cursor, so don't display it
561 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
563 int cursor_on_p
, mouse_face_overwritten_p
;
565 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
567 if (!w
->pseudo_window_p
)
572 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
574 output_cursor
.x
, output_cursor
.y
);
576 if (draw_window_fringes (w
, 1))
577 x_draw_vertical_border (w
);
582 /* If a row with mouse-face was overwritten, arrange for
583 XTframe_up_to_date to redisplay the mouse highlight. */
584 if (mouse_face_overwritten_p
)
586 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
587 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
588 dpyinfo
->mouse_face_window
= Qnil
;
591 updated_window
= NULL
;
595 /* End update of frame F. This function is installed as a hook in
602 /* Mouse highlight may be displayed again. */
603 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
607 XFlush (FRAME_X_DISPLAY (f
));
613 /* This function is called from various places in xdisp.c whenever a
614 complete update has been performed. The global variable
615 updated_window is not available here. */
618 XTframe_up_to_date (f
)
623 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
625 if (dpyinfo
->mouse_face_deferred_gc
626 || f
== dpyinfo
->mouse_face_mouse_frame
)
629 if (dpyinfo
->mouse_face_mouse_frame
)
630 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
631 dpyinfo
->mouse_face_mouse_x
,
632 dpyinfo
->mouse_face_mouse_y
);
633 dpyinfo
->mouse_face_deferred_gc
= 0;
640 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
641 arrow bitmaps, or clear the fringes if no bitmaps are required
642 before DESIRED_ROW is made current. The window being updated is
643 found in updated_window. This function It is called from
644 update_window_line only if it is known that there are differences
645 between bitmaps to be drawn between current row and DESIRED_ROW. */
648 x_after_update_window_line (desired_row
)
649 struct glyph_row
*desired_row
;
651 struct window
*w
= updated_window
;
657 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
658 desired_row
->redraw_fringe_bitmaps_p
= 1;
660 /* When a window has disappeared, make sure that no rest of
661 full-width rows stays visible in the internal border. Could
662 check here if updated_window is the leftmost/rightmost window,
663 but I guess it's not worth doing since vertically split windows
664 are almost never used, internal border is rarely set, and the
665 overhead is very small. */
666 if (windows_or_buffers_changed
667 && desired_row
->full_width_p
668 && (f
= XFRAME (w
->frame
),
669 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
671 && (height
= desired_row
->visible_height
,
674 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
676 /* Internal border is drawn below the tool bar. */
677 if (WINDOWP (f
->tool_bar_window
)
678 && w
== XWINDOW (f
->tool_bar_window
))
682 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
683 0, y
, width
, height
, False
);
684 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
685 FRAME_PIXEL_WIDTH (f
) - width
,
686 y
, width
, height
, False
);
692 x_draw_fringe_bitmap (w
, row
, p
)
694 struct glyph_row
*row
;
695 struct draw_fringe_bitmap_params
*p
;
697 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
698 Display
*display
= FRAME_X_DISPLAY (f
);
699 Window window
= FRAME_X_WINDOW (f
);
700 GC gc
= f
->output_data
.x
->normal_gc
;
701 struct face
*face
= p
->face
;
704 /* Must clip because of partially visible lines. */
705 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
708 /* Adjust position of "bottom aligned" bitmap on partially
711 int oldVH
= row
->visible_height
;
712 row
->visible_height
= p
->h
;
713 row
->y
-= rowY
- p
->y
;
714 x_clip_to_row (w
, row
, -1, gc
);
716 row
->visible_height
= oldVH
;
719 x_clip_to_row (w
, row
, -1, gc
);
721 if (p
->bx
>= 0 && !p
->overlay_p
)
723 /* In case the same realized face is used for fringes and
724 for something displayed in the text (e.g. face `region' on
725 mono-displays, the fill style may have been changed to
726 FillSolid in x_draw_glyph_string_background. */
728 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
730 XSetForeground (display
, face
->gc
, face
->background
);
732 XFillRectangle (display
, window
, face
->gc
,
733 p
->bx
, p
->by
, p
->nx
, p
->ny
);
736 XSetForeground (display
, face
->gc
, face
->foreground
);
742 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
743 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
747 bits
= (unsigned char *)(p
->bits
+ p
->dh
);
749 bits
= (unsigned char *)p
->bits
+ p
->dh
;
751 /* Draw the bitmap. I believe these small pixmaps can be cached
753 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
755 ? (p
->overlay_p
? face
->background
756 : f
->output_data
.x
->cursor_pixel
)
758 face
->background
, depth
);
762 clipmask
= XCreatePixmapFromBitmapData (display
,
763 FRAME_X_DISPLAY_INFO (f
)->root_window
,
766 gcv
.clip_mask
= clipmask
;
767 gcv
.clip_x_origin
= p
->x
;
768 gcv
.clip_y_origin
= p
->y
;
769 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
772 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
773 p
->wd
, p
->h
, p
->x
, p
->y
);
774 XFreePixmap (display
, pixmap
);
778 gcv
.clip_mask
= (Pixmap
) 0;
779 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
780 XFreePixmap (display
, clipmask
);
784 XSetClipMask (display
, gc
, None
);
789 /* This is called when starting Emacs and when restarting after
790 suspend. When starting Emacs, no X window is mapped. And nothing
791 must be done to Emacs's own window if it is suspended (though that
795 XTset_terminal_modes ()
799 /* This is called when exiting or suspending Emacs. Exiting will make
800 the X-windows go away, and suspending requires no action. */
803 XTreset_terminal_modes ()
809 /***********************************************************************
811 ***********************************************************************/
813 /* Function prototypes of this page. */
815 static int x_encode_char
P_ ((int, XChar2b
*, struct font_info
*, int *));
818 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
819 is not contained in the font. */
822 x_per_char_metric (font
, char2b
, font_type
)
825 int font_type
; /* unused on X */
827 /* The result metric information. */
828 XCharStruct
*pcm
= NULL
;
830 xassert (font
&& char2b
);
832 if (font
->per_char
!= NULL
)
834 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
836 /* min_char_or_byte2 specifies the linear character index
837 corresponding to the first element of the per_char array,
838 max_char_or_byte2 is the index of the last character. A
839 character with non-zero CHAR2B->byte1 is not in the font.
840 A character with byte2 less than min_char_or_byte2 or
841 greater max_char_or_byte2 is not in the font. */
842 if (char2b
->byte1
== 0
843 && char2b
->byte2
>= font
->min_char_or_byte2
844 && char2b
->byte2
<= font
->max_char_or_byte2
)
845 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
849 /* If either min_byte1 or max_byte1 are nonzero, both
850 min_char_or_byte2 and max_char_or_byte2 are less than
851 256, and the 2-byte character index values corresponding
852 to the per_char array element N (counting from 0) are:
854 byte1 = N/D + min_byte1
855 byte2 = N\D + min_char_or_byte2
859 D = max_char_or_byte2 - min_char_or_byte2 + 1
861 \ = integer modulus */
862 if (char2b
->byte1
>= font
->min_byte1
863 && char2b
->byte1
<= font
->max_byte1
864 && char2b
->byte2
>= font
->min_char_or_byte2
865 && char2b
->byte2
<= font
->max_char_or_byte2
)
867 pcm
= (font
->per_char
868 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
869 * (char2b
->byte1
- font
->min_byte1
))
870 + (char2b
->byte2
- font
->min_char_or_byte2
));
876 /* If the per_char pointer is null, all glyphs between the first
877 and last character indexes inclusive have the same
878 information, as given by both min_bounds and max_bounds. */
879 if (char2b
->byte2
>= font
->min_char_or_byte2
880 && char2b
->byte2
<= font
->max_char_or_byte2
)
881 pcm
= &font
->max_bounds
;
885 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
890 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
891 the two-byte form of C. Encoding is returned in *CHAR2B. */
894 x_encode_char (c
, char2b
, font_info
, two_byte_p
)
897 struct font_info
*font_info
;
900 int charset
= CHAR_CHARSET (c
);
901 XFontStruct
*font
= font_info
->font
;
903 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
904 This may be either a program in a special encoder language or a
906 if (font_info
->font_encoder
)
908 /* It's a program. */
909 struct ccl_program
*ccl
= font_info
->font_encoder
;
911 check_ccl_update (ccl
);
912 if (CHARSET_DIMENSION (charset
) == 1)
914 ccl
->reg
[0] = charset
;
915 ccl
->reg
[1] = char2b
->byte2
;
920 ccl
->reg
[0] = charset
;
921 ccl
->reg
[1] = char2b
->byte1
;
922 ccl
->reg
[2] = char2b
->byte2
;
925 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
927 /* We assume that MSBs are appropriately set/reset by CCL
929 if (font
->max_byte1
== 0) /* 1-byte font */
930 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
932 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
934 else if (font_info
->encoding
[charset
])
936 /* Fixed encoding scheme. See fontset.h for the meaning of the
938 int enc
= font_info
->encoding
[charset
];
940 if ((enc
== 1 || enc
== 2)
941 && CHARSET_DIMENSION (charset
) == 2)
942 char2b
->byte1
|= 0x80;
944 if (enc
== 1 || enc
== 3)
945 char2b
->byte2
|= 0x80;
949 *two_byte_p
= ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
951 return FONT_TYPE_UNKNOWN
;
956 /***********************************************************************
958 ***********************************************************************/
962 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
963 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
964 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
966 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
967 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
968 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
969 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
970 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
971 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
972 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
973 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
974 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
975 unsigned long *, double, int));
976 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
977 double, int, unsigned long));
978 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
979 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
980 static void x_draw_image_relief
P_ ((struct glyph_string
*));
981 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
982 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
983 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
985 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
986 int, int, int, int, int, int,
988 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
989 int, int, int, XRectangle
*));
992 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
996 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1001 struct glyph_string
*s
;
1003 if (s
->font
== FRAME_FONT (s
->f
)
1004 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1005 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1007 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
1010 /* Cursor on non-default face: must merge. */
1014 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
1015 xgcv
.foreground
= s
->face
->background
;
1017 /* If the glyph would be invisible, try a different foreground. */
1018 if (xgcv
.foreground
== xgcv
.background
)
1019 xgcv
.foreground
= s
->face
->foreground
;
1020 if (xgcv
.foreground
== xgcv
.background
)
1021 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
1022 if (xgcv
.foreground
== xgcv
.background
)
1023 xgcv
.foreground
= s
->face
->foreground
;
1025 /* Make sure the cursor is distinct from text in this face. */
1026 if (xgcv
.background
== s
->face
->background
1027 && xgcv
.foreground
== s
->face
->foreground
)
1029 xgcv
.background
= s
->face
->foreground
;
1030 xgcv
.foreground
= s
->face
->background
;
1033 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1034 xgcv
.font
= s
->font
->fid
;
1035 xgcv
.graphics_exposures
= False
;
1036 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
1038 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1039 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1042 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1043 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1045 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1050 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1053 x_set_mouse_face_gc (s
)
1054 struct glyph_string
*s
;
1059 /* What face has to be used last for the mouse face? */
1060 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1061 face
= FACE_FROM_ID (s
->f
, face_id
);
1063 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1065 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1066 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
1068 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
1069 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1070 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1072 /* If font in this face is same as S->font, use it. */
1073 if (s
->font
== s
->face
->font
)
1074 s
->gc
= s
->face
->gc
;
1077 /* Otherwise construct scratch_cursor_gc with values from FACE
1082 xgcv
.background
= s
->face
->background
;
1083 xgcv
.foreground
= s
->face
->foreground
;
1084 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1085 xgcv
.font
= s
->font
->fid
;
1086 xgcv
.graphics_exposures
= False
;
1087 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
1089 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1090 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1093 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1094 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1096 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1099 xassert (s
->gc
!= 0);
1103 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1104 Faces to use in the mode line have already been computed when the
1105 matrix was built, so there isn't much to do, here. */
1108 x_set_mode_line_face_gc (s
)
1109 struct glyph_string
*s
;
1111 s
->gc
= s
->face
->gc
;
1115 /* Set S->gc of glyph string S for drawing that glyph string. Set
1116 S->stippled_p to a non-zero value if the face of S has a stipple
1120 x_set_glyph_string_gc (s
)
1121 struct glyph_string
*s
;
1123 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1125 if (s
->hl
== DRAW_NORMAL_TEXT
)
1127 s
->gc
= s
->face
->gc
;
1128 s
->stippled_p
= s
->face
->stipple
!= 0;
1130 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1132 x_set_mode_line_face_gc (s
);
1133 s
->stippled_p
= s
->face
->stipple
!= 0;
1135 else if (s
->hl
== DRAW_CURSOR
)
1137 x_set_cursor_gc (s
);
1140 else if (s
->hl
== DRAW_MOUSE_FACE
)
1142 x_set_mouse_face_gc (s
);
1143 s
->stippled_p
= s
->face
->stipple
!= 0;
1145 else if (s
->hl
== DRAW_IMAGE_RAISED
1146 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1148 s
->gc
= s
->face
->gc
;
1149 s
->stippled_p
= s
->face
->stipple
!= 0;
1153 s
->gc
= s
->face
->gc
;
1154 s
->stippled_p
= s
->face
->stipple
!= 0;
1157 /* GC must have been set. */
1158 xassert (s
->gc
!= 0);
1162 /* Set clipping for output of glyph string S. S may be part of a mode
1163 line or menu if we don't have X toolkit support. */
1166 x_set_glyph_string_clipping (s
)
1167 struct glyph_string
*s
;
1170 get_glyph_string_clip_rect (s
, &r
);
1171 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
1176 Compute left and right overhang of glyph string S. If S is a glyph
1177 string for a composition, assume overhangs don't exist. */
1180 x_compute_glyph_string_overhangs (s
)
1181 struct glyph_string
*s
;
1184 && s
->first_glyph
->type
== CHAR_GLYPH
)
1187 int direction
, font_ascent
, font_descent
;
1188 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
1189 &font_ascent
, &font_descent
, &cs
);
1190 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
1191 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
1196 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1199 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1200 struct glyph_string
*s
;
1204 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1205 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1206 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1207 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1211 /* Draw the background of glyph_string S. If S->background_filled_p
1212 is non-zero don't draw it. FORCE_P non-zero means draw the
1213 background even if it wouldn't be drawn normally. This is used
1214 when a string preceding S draws into the background of S, or S
1215 contains the first component of a composition. */
1218 x_draw_glyph_string_background (s
, force_p
)
1219 struct glyph_string
*s
;
1222 /* Nothing to do if background has already been drawn or if it
1223 shouldn't be drawn in the first place. */
1224 if (!s
->background_filled_p
)
1226 int box_line_width
= max (s
->face
->box_line_width
, 0);
1230 /* Fill background with a stipple pattern. */
1231 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1232 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1233 s
->y
+ box_line_width
,
1234 s
->background_width
,
1235 s
->height
- 2 * box_line_width
);
1236 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1237 s
->background_filled_p
= 1;
1239 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1240 || s
->font_not_found_p
1241 || s
->extends_to_end_of_line_p
1244 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1245 s
->background_width
,
1246 s
->height
- 2 * box_line_width
);
1247 s
->background_filled_p
= 1;
1253 /* Draw the foreground of glyph string S. */
1256 x_draw_glyph_string_foreground (s
)
1257 struct glyph_string
*s
;
1261 /* If first glyph of S has a left box line, start drawing the text
1262 of S to the right of that box line. */
1263 if (s
->face
->box
!= FACE_NO_BOX
1264 && s
->first_glyph
->left_box_line_p
)
1265 x
= s
->x
+ abs (s
->face
->box_line_width
);
1269 /* Draw characters of S as rectangles if S's font could not be
1271 if (s
->font_not_found_p
)
1273 for (i
= 0; i
< s
->nchars
; ++i
)
1275 struct glyph
*g
= s
->first_glyph
+ i
;
1276 XDrawRectangle (s
->display
, s
->window
,
1277 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1279 x
+= g
->pixel_width
;
1284 char *char1b
= (char *) s
->char2b
;
1285 int boff
= s
->font_info
->baseline_offset
;
1287 if (s
->font_info
->vertical_centering
)
1288 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
1290 /* If we can use 8-bit functions, condense S->char2b. */
1292 for (i
= 0; i
< s
->nchars
; ++i
)
1293 char1b
[i
] = s
->char2b
[i
].byte2
;
1295 /* Draw text with XDrawString if background has already been
1296 filled. Otherwise, use XDrawImageString. (Note that
1297 XDrawImageString is usually faster than XDrawString.) Always
1298 use XDrawImageString when drawing the cursor so that there is
1299 no chance that characters under a box cursor are invisible. */
1301 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1303 /* Draw characters with 16-bit or 8-bit functions. */
1305 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
1306 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1308 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
1309 s
->ybase
- boff
, char1b
, s
->nchars
);
1314 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
1315 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1317 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
1318 s
->ybase
- boff
, char1b
, s
->nchars
);
1321 if (s
->face
->overstrike
)
1323 /* For overstriking (to simulate bold-face), draw the
1324 characters again shifted to the right by one pixel. */
1326 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
+ 1,
1327 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1329 XDrawString (s
->display
, s
->window
, s
->gc
, x
+ 1,
1330 s
->ybase
- boff
, char1b
, s
->nchars
);
1335 /* Draw the foreground of composite glyph string S. */
1338 x_draw_composite_glyph_string_foreground (s
)
1339 struct glyph_string
*s
;
1343 /* If first glyph of S has a left box line, start drawing the text
1344 of S to the right of that box line. */
1345 if (s
->face
->box
!= FACE_NO_BOX
1346 && s
->first_glyph
->left_box_line_p
)
1347 x
= s
->x
+ abs (s
->face
->box_line_width
);
1351 /* S is a glyph string for a composition. S->gidx is the index of
1352 the first character drawn for glyphs of this composition.
1353 S->gidx == 0 means we are drawing the very first character of
1354 this composition. */
1356 /* Draw a rectangle for the composition if the font for the very
1357 first character of the composition could not be loaded. */
1358 if (s
->font_not_found_p
)
1361 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1362 s
->width
- 1, s
->height
- 1);
1366 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
1368 XDrawString16 (s
->display
, s
->window
, s
->gc
,
1369 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
1370 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1372 if (s
->face
->overstrike
)
1373 XDrawString16 (s
->display
, s
->window
, s
->gc
,
1374 x
+ s
->cmp
->offsets
[s
->gidx
* 2] + 1,
1375 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1382 #ifdef USE_X_TOOLKIT
1384 static struct frame
*x_frame_of_widget
P_ ((Widget
));
1385 static Boolean cvt_string_to_pixel
P_ ((Display
*, XrmValue
*, Cardinal
*,
1386 XrmValue
*, XrmValue
*, XtPointer
*));
1387 static void cvt_pixel_dtor
P_ ((XtAppContext
, XrmValue
*, XtPointer
,
1388 XrmValue
*, Cardinal
*));
1391 /* Return the frame on which widget WIDGET is used.. Abort if frame
1392 cannot be determined. */
1394 static struct frame
*
1395 x_frame_of_widget (widget
)
1398 struct x_display_info
*dpyinfo
;
1402 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1404 /* Find the top-level shell of the widget. Note that this function
1405 can be called when the widget is not yet realized, so XtWindow
1406 (widget) == 0. That's the reason we can't simply use
1407 x_any_window_to_frame. */
1408 while (!XtIsTopLevelShell (widget
))
1409 widget
= XtParent (widget
);
1411 /* Look for a frame with that top-level widget. Allocate the color
1412 on that frame to get the right gamma correction value. */
1413 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1414 if (GC_FRAMEP (XCAR (tail
))
1415 && (f
= XFRAME (XCAR (tail
)),
1416 (f
->output_data
.nothing
!= 1
1417 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1418 && f
->output_data
.x
->widget
== widget
)
1425 /* Allocate the color COLOR->pixel on the screen and display of
1426 widget WIDGET in colormap CMAP. If an exact match cannot be
1427 allocated, try the nearest color available. Value is non-zero
1428 if successful. This is called from lwlib. */
1431 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
1436 struct frame
*f
= x_frame_of_widget (widget
);
1437 return x_alloc_nearest_color (f
, cmap
, color
);
1441 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1442 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1443 If this produces the same color as PIXEL, try a color where all RGB
1444 values have DELTA added. Return the allocated color in *PIXEL.
1445 DISPLAY is the X display, CMAP is the colormap to operate on.
1446 Value is non-zero if successful. */
1449 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
1453 unsigned long *pixel
;
1457 struct frame
*f
= x_frame_of_widget (widget
);
1458 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1462 /* Structure specifying which arguments should be passed by Xt to
1463 cvt_string_to_pixel. We want the widget's screen and colormap. */
1465 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1467 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1469 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1474 /* The address of this variable is returned by
1475 cvt_string_to_pixel. */
1477 static Pixel cvt_string_to_pixel_value
;
1480 /* Convert a color name to a pixel color.
1482 DPY is the display we are working on.
1484 ARGS is an array of *NARGS XrmValue structures holding additional
1485 information about the widget for which the conversion takes place.
1486 The contents of this array are determined by the specification
1487 in cvt_string_to_pixel_args.
1489 FROM is a pointer to an XrmValue which points to the color name to
1490 convert. TO is an XrmValue in which to return the pixel color.
1492 CLOSURE_RET is a pointer to user-data, in which we record if
1493 we allocated the color or not.
1495 Value is True if successful, False otherwise. */
1498 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
1502 XrmValue
*from
, *to
;
1503 XtPointer
*closure_ret
;
1513 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1514 "wrongParameters", "cvt_string_to_pixel",
1516 "Screen and colormap args required", NULL
, NULL
);
1520 screen
= *(Screen
**) args
[0].addr
;
1521 cmap
= *(Colormap
*) args
[1].addr
;
1522 color_name
= (String
) from
->addr
;
1524 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1526 *closure_ret
= (XtPointer
) False
;
1527 pixel
= WhitePixelOfScreen (screen
);
1529 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1531 *closure_ret
= (XtPointer
) False
;
1532 pixel
= BlackPixelOfScreen (screen
);
1534 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1535 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1537 pixel
= color
.pixel
;
1538 *closure_ret
= (XtPointer
) True
;
1543 Cardinal nparams
= 1;
1545 params
[0] = color_name
;
1546 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1547 "badValue", "cvt_string_to_pixel",
1548 "XtToolkitError", "Invalid color `%s'",
1553 if (to
->addr
!= NULL
)
1555 if (to
->size
< sizeof (Pixel
))
1557 to
->size
= sizeof (Pixel
);
1561 *(Pixel
*) to
->addr
= pixel
;
1565 cvt_string_to_pixel_value
= pixel
;
1566 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1569 to
->size
= sizeof (Pixel
);
1574 /* Free a pixel color which was previously allocated via
1575 cvt_string_to_pixel. This is registered as the destructor
1576 for this type of resource via XtSetTypeConverter.
1578 APP is the application context in which we work.
1580 TO is a pointer to an XrmValue holding the color to free.
1581 CLOSURE is the value we stored in CLOSURE_RET for this color
1582 in cvt_string_to_pixel.
1584 ARGS and NARGS are like for cvt_string_to_pixel. */
1587 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
1596 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1598 "Screen and colormap arguments required",
1601 else if (closure
!= NULL
)
1603 /* We did allocate the pixel, so free it. */
1604 Screen
*screen
= *(Screen
**) args
[0].addr
;
1605 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1606 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1607 (Pixel
*) to
->addr
, 1);
1612 #endif /* USE_X_TOOLKIT */
1615 /* Value is an array of XColor structures for the contents of the
1616 color map of display DPY. Set *NCELLS to the size of the array.
1617 Note that this probably shouldn't be called for large color maps,
1618 say a 24-bit TrueColor map. */
1620 static const XColor
*
1621 x_color_cells (dpy
, ncells
)
1625 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1627 if (dpyinfo
->color_cells
== NULL
)
1629 Screen
*screen
= dpyinfo
->screen
;
1632 dpyinfo
->ncolor_cells
1633 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1634 dpyinfo
->color_cells
1635 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1636 * sizeof *dpyinfo
->color_cells
);
1638 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1639 dpyinfo
->color_cells
[i
].pixel
= i
;
1641 XQueryColors (dpy
, dpyinfo
->cmap
,
1642 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1645 *ncells
= dpyinfo
->ncolor_cells
;
1646 return dpyinfo
->color_cells
;
1650 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1651 colors in COLORS. Use cached information, if available. */
1654 x_query_colors (f
, colors
, ncolors
)
1659 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1661 if (dpyinfo
->color_cells
)
1664 for (i
= 0; i
< ncolors
; ++i
)
1666 unsigned long pixel
= colors
[i
].pixel
;
1667 xassert (pixel
< dpyinfo
->ncolor_cells
);
1668 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1669 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1673 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1677 /* On frame F, translate pixel color to RGB values for the color in
1678 COLOR. Use cached information, if available. */
1681 x_query_color (f
, color
)
1685 x_query_colors (f
, color
, 1);
1689 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1690 exact match can't be allocated, try the nearest color available.
1691 Value is non-zero if successful. Set *COLOR to the color
1695 x_alloc_nearest_color_1 (dpy
, cmap
, color
)
1702 rc
= XAllocColor (dpy
, cmap
, color
);
1705 /* If we got to this point, the colormap is full, so we're going
1706 to try to get the next closest color. The algorithm used is
1707 a least-squares matching, which is what X uses for closest
1708 color matching with StaticColor visuals. */
1710 unsigned long nearest_delta
= ~0;
1712 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1714 for (nearest
= i
= 0; i
< ncells
; ++i
)
1716 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1717 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1718 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1719 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1721 if (delta
< nearest_delta
)
1724 nearest_delta
= delta
;
1728 color
->red
= cells
[nearest
].red
;
1729 color
->green
= cells
[nearest
].green
;
1730 color
->blue
= cells
[nearest
].blue
;
1731 rc
= XAllocColor (dpy
, cmap
, color
);
1735 /* If allocation succeeded, and the allocated pixel color is not
1736 equal to a cached pixel color recorded earlier, there was a
1737 change in the colormap, so clear the color cache. */
1738 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1739 XColor
*cached_color
;
1741 if (dpyinfo
->color_cells
1742 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1743 (cached_color
->red
!= color
->red
1744 || cached_color
->blue
!= color
->blue
1745 || cached_color
->green
!= color
->green
)))
1747 xfree (dpyinfo
->color_cells
);
1748 dpyinfo
->color_cells
= NULL
;
1749 dpyinfo
->ncolor_cells
= 0;
1753 #ifdef DEBUG_X_COLORS
1755 register_color (color
->pixel
);
1756 #endif /* DEBUG_X_COLORS */
1762 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1763 exact match can't be allocated, try the nearest color available.
1764 Value is non-zero if successful. Set *COLOR to the color
1768 x_alloc_nearest_color (f
, cmap
, color
)
1773 gamma_correct (f
, color
);
1774 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1778 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1779 It's necessary to do this instead of just using PIXEL directly to
1780 get color reference counts right. */
1783 x_copy_color (f
, pixel
)
1785 unsigned long pixel
;
1789 color
.pixel
= pixel
;
1791 x_query_color (f
, &color
);
1792 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1794 #ifdef DEBUG_X_COLORS
1795 register_color (pixel
);
1801 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1802 It's necessary to do this instead of just using PIXEL directly to
1803 get color reference counts right. */
1806 x_copy_dpy_color (dpy
, cmap
, pixel
)
1809 unsigned long pixel
;
1813 color
.pixel
= pixel
;
1815 XQueryColor (dpy
, cmap
, &color
);
1816 XAllocColor (dpy
, cmap
, &color
);
1818 #ifdef DEBUG_X_COLORS
1819 register_color (pixel
);
1825 /* Brightness beyond which a color won't have its highlight brightness
1828 Nominally, highlight colors for `3d' faces are calculated by
1829 brightening an object's color by a constant scale factor, but this
1830 doesn't yield good results for dark colors, so for colors who's
1831 brightness is less than this value (on a scale of 0-65535) have an
1832 use an additional additive factor.
1834 The value here is set so that the default menu-bar/mode-line color
1835 (grey75) will not have its highlights changed at all. */
1836 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1839 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1840 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1841 If this produces the same color as PIXEL, try a color where all RGB
1842 values have DELTA added. Return the allocated color in *PIXEL.
1843 DISPLAY is the X display, CMAP is the colormap to operate on.
1844 Value is non-zero if successful. */
1847 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
1851 unsigned long *pixel
;
1859 /* Get RGB color values. */
1860 color
.pixel
= *pixel
;
1861 x_query_color (f
, &color
);
1863 /* Change RGB values by specified FACTOR. Avoid overflow! */
1864 xassert (factor
>= 0);
1865 new.red
= min (0xffff, factor
* color
.red
);
1866 new.green
= min (0xffff, factor
* color
.green
);
1867 new.blue
= min (0xffff, factor
* color
.blue
);
1869 /* Calculate brightness of COLOR. */
1870 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1872 /* We only boost colors that are darker than
1873 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1874 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1875 /* Make an additive adjustment to NEW, because it's dark enough so
1876 that scaling by FACTOR alone isn't enough. */
1878 /* How far below the limit this color is (0 - 1, 1 being darker). */
1879 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1880 /* The additive adjustment. */
1881 int min_delta
= delta
* dimness
* factor
/ 2;
1885 new.red
= max (0, new.red
- min_delta
);
1886 new.green
= max (0, new.green
- min_delta
);
1887 new.blue
= max (0, new.blue
- min_delta
);
1891 new.red
= min (0xffff, min_delta
+ new.red
);
1892 new.green
= min (0xffff, min_delta
+ new.green
);
1893 new.blue
= min (0xffff, min_delta
+ new.blue
);
1897 /* Try to allocate the color. */
1898 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1901 if (new.pixel
== *pixel
)
1903 /* If we end up with the same color as before, try adding
1904 delta to the RGB values. */
1905 x_free_colors (f
, &new.pixel
, 1);
1907 new.red
= min (0xffff, delta
+ color
.red
);
1908 new.green
= min (0xffff, delta
+ color
.green
);
1909 new.blue
= min (0xffff, delta
+ color
.blue
);
1910 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1921 /* Set up the foreground color for drawing relief lines of glyph
1922 string S. RELIEF is a pointer to a struct relief containing the GC
1923 with which lines will be drawn. Use a color that is FACTOR or
1924 DELTA lighter or darker than the relief's background which is found
1925 in S->f->output_data.x->relief_background. If such a color cannot
1926 be allocated, use DEFAULT_PIXEL, instead. */
1929 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1931 struct relief
*relief
;
1934 unsigned long default_pixel
;
1937 struct x_output
*di
= f
->output_data
.x
;
1938 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1939 unsigned long pixel
;
1940 unsigned long background
= di
->relief_background
;
1941 Colormap cmap
= FRAME_X_COLORMAP (f
);
1942 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1943 Display
*dpy
= FRAME_X_DISPLAY (f
);
1945 xgcv
.graphics_exposures
= False
;
1946 xgcv
.line_width
= 1;
1948 /* Free previously allocated color. The color cell will be reused
1949 when it has been freed as many times as it was allocated, so this
1950 doesn't affect faces using the same colors. */
1952 && relief
->allocated_p
)
1954 x_free_colors (f
, &relief
->pixel
, 1);
1955 relief
->allocated_p
= 0;
1958 /* Allocate new color. */
1959 xgcv
.foreground
= default_pixel
;
1961 if (dpyinfo
->n_planes
!= 1
1962 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1964 relief
->allocated_p
= 1;
1965 xgcv
.foreground
= relief
->pixel
= pixel
;
1968 if (relief
->gc
== 0)
1970 xgcv
.stipple
= dpyinfo
->gray
;
1972 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1975 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1979 /* Set up colors for the relief lines around glyph string S. */
1982 x_setup_relief_colors (s
)
1983 struct glyph_string
*s
;
1985 struct x_output
*di
= s
->f
->output_data
.x
;
1986 unsigned long color
;
1988 if (s
->face
->use_box_color_for_shadows_p
)
1989 color
= s
->face
->box_color
;
1990 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1992 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1993 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1998 /* Get the background color of the face. */
1999 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
2000 color
= xgcv
.background
;
2003 if (di
->white_relief
.gc
== 0
2004 || color
!= di
->relief_background
)
2006 di
->relief_background
= color
;
2007 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2008 WHITE_PIX_DEFAULT (s
->f
));
2009 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2010 BLACK_PIX_DEFAULT (s
->f
));
2015 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2016 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2017 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
2018 relief. LEFT_P non-zero means draw a relief on the left side of
2019 the rectangle. RIGHT_P non-zero means draw a relief on the right
2020 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2024 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
2025 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
2027 int left_x
, top_y
, right_x
, bottom_y
, width
;
2028 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
2029 XRectangle
*clip_rect
;
2031 Display
*dpy
= FRAME_X_DISPLAY (f
);
2032 Window window
= FRAME_X_WINDOW (f
);
2037 gc
= f
->output_data
.x
->white_relief
.gc
;
2039 gc
= f
->output_data
.x
->black_relief
.gc
;
2040 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2044 for (i
= 0; i
< width
; ++i
)
2045 XDrawLine (dpy
, window
, gc
,
2046 left_x
+ i
* left_p
, top_y
+ i
,
2047 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2051 for (i
= 0; i
< width
; ++i
)
2052 XDrawLine (dpy
, window
, gc
,
2053 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
2055 XSetClipMask (dpy
, gc
, None
);
2057 gc
= f
->output_data
.x
->black_relief
.gc
;
2059 gc
= f
->output_data
.x
->white_relief
.gc
;
2060 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2064 for (i
= 0; i
< width
; ++i
)
2065 XDrawLine (dpy
, window
, gc
,
2066 left_x
+ i
* left_p
, bottom_y
- i
,
2067 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2071 for (i
= 0; i
< width
; ++i
)
2072 XDrawLine (dpy
, window
, gc
,
2073 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2075 XSetClipMask (dpy
, gc
, None
);
2079 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2080 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2081 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2082 left side of the rectangle. RIGHT_P non-zero means draw a line
2083 on the right side of the rectangle. CLIP_RECT is the clipping
2084 rectangle to use when drawing. */
2087 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2088 left_p
, right_p
, clip_rect
)
2089 struct glyph_string
*s
;
2090 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2091 XRectangle
*clip_rect
;
2095 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2096 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2097 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2100 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2101 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2105 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2106 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2109 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2110 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2114 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2115 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2117 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2118 XSetClipMask (s
->display
, s
->gc
, None
);
2122 /* Draw a box around glyph string S. */
2125 x_draw_glyph_string_box (s
)
2126 struct glyph_string
*s
;
2128 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2129 int left_p
, right_p
;
2130 struct glyph
*last_glyph
;
2131 XRectangle clip_rect
;
2133 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2134 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2135 : window_box_right (s
->w
, s
->area
));
2137 /* The glyph that may have a right box line. */
2138 last_glyph
= (s
->cmp
|| s
->img
2140 : s
->first_glyph
+ s
->nchars
- 1);
2142 width
= abs (s
->face
->box_line_width
);
2143 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2145 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2147 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2149 bottom_y
= top_y
+ s
->height
- 1;
2151 left_p
= (s
->first_glyph
->left_box_line_p
2152 || (s
->hl
== DRAW_MOUSE_FACE
2154 || s
->prev
->hl
!= s
->hl
)));
2155 right_p
= (last_glyph
->right_box_line_p
2156 || (s
->hl
== DRAW_MOUSE_FACE
2158 || s
->next
->hl
!= s
->hl
)));
2160 get_glyph_string_clip_rect (s
, &clip_rect
);
2162 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2163 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2164 left_p
, right_p
, &clip_rect
);
2167 x_setup_relief_colors (s
);
2168 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2169 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2174 /* Draw foreground of image glyph string S. */
2177 x_draw_image_foreground (s
)
2178 struct glyph_string
*s
;
2181 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2183 /* If first glyph of S has a left box line, start drawing it to the
2184 right of that line. */
2185 if (s
->face
->box
!= FACE_NO_BOX
2186 && s
->first_glyph
->left_box_line_p
2188 x
+= abs (s
->face
->box_line_width
);
2190 /* If there is a margin around the image, adjust x- and y-position
2192 if (s
->slice
.x
== 0)
2193 x
+= s
->img
->hmargin
;
2194 if (s
->slice
.y
== 0)
2195 y
+= s
->img
->vmargin
;
2201 /* We can't set both a clip mask and use XSetClipRectangles
2202 because the latter also sets a clip mask. We also can't
2203 trust on the shape extension to be available
2204 (XShapeCombineRegion). So, compute the rectangle to draw
2206 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2209 XRectangle clip_rect
, image_rect
, r
;
2211 xgcv
.clip_mask
= s
->img
->mask
;
2212 xgcv
.clip_x_origin
= x
;
2213 xgcv
.clip_y_origin
= y
;
2214 xgcv
.function
= GXcopy
;
2215 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2217 get_glyph_string_clip_rect (s
, &clip_rect
);
2220 image_rect
.width
= s
->slice
.width
;
2221 image_rect
.height
= s
->slice
.height
;
2222 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2223 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2224 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2225 r
.width
, r
.height
, r
.x
, r
.y
);
2229 XRectangle clip_rect
, image_rect
, r
;
2231 get_glyph_string_clip_rect (s
, &clip_rect
);
2234 image_rect
.width
= s
->slice
.width
;
2235 image_rect
.height
= s
->slice
.height
;
2236 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2237 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2238 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2239 r
.width
, r
.height
, r
.x
, r
.y
);
2241 /* When the image has a mask, we can expect that at
2242 least part of a mouse highlight or a block cursor will
2243 be visible. If the image doesn't have a mask, make
2244 a block cursor visible by drawing a rectangle around
2245 the image. I believe it's looking better if we do
2246 nothing here for mouse-face. */
2247 if (s
->hl
== DRAW_CURSOR
)
2249 int r
= s
->img
->relief
;
2251 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2253 s
->slice
.width
+ r
*2 - 1,
2254 s
->slice
.height
+ r
*2 - 1);
2259 /* Draw a rectangle if image could not be loaded. */
2260 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2261 s
->slice
.width
- 1, s
->slice
.height
- 1);
2265 /* Draw a relief around the image glyph string S. */
2268 x_draw_image_relief (s
)
2269 struct glyph_string
*s
;
2271 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2274 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2276 /* If first glyph of S has a left box line, start drawing it to the
2277 right of that line. */
2278 if (s
->face
->box
!= FACE_NO_BOX
2279 && s
->first_glyph
->left_box_line_p
2281 x
+= abs (s
->face
->box_line_width
);
2283 /* If there is a margin around the image, adjust x- and y-position
2285 if (s
->slice
.x
== 0)
2286 x
+= s
->img
->hmargin
;
2287 if (s
->slice
.y
== 0)
2288 y
+= s
->img
->vmargin
;
2290 if (s
->hl
== DRAW_IMAGE_SUNKEN
2291 || s
->hl
== DRAW_IMAGE_RAISED
)
2293 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2294 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2298 thick
= abs (s
->img
->relief
);
2299 raised_p
= s
->img
->relief
> 0;
2304 x1
= x
+ s
->slice
.width
+ thick
- 1;
2305 y1
= y
+ s
->slice
.height
+ thick
- 1;
2307 x_setup_relief_colors (s
);
2308 get_glyph_string_clip_rect (s
, &r
);
2309 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2311 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2313 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2318 /* Draw the foreground of image glyph string S to PIXMAP. */
2321 x_draw_image_foreground_1 (s
, pixmap
)
2322 struct glyph_string
*s
;
2326 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2328 /* If first glyph of S has a left box line, start drawing it to the
2329 right of that line. */
2330 if (s
->face
->box
!= FACE_NO_BOX
2331 && s
->first_glyph
->left_box_line_p
2333 x
+= abs (s
->face
->box_line_width
);
2335 /* If there is a margin around the image, adjust x- and y-position
2337 if (s
->slice
.x
== 0)
2338 x
+= s
->img
->hmargin
;
2339 if (s
->slice
.y
== 0)
2340 y
+= s
->img
->vmargin
;
2346 /* We can't set both a clip mask and use XSetClipRectangles
2347 because the latter also sets a clip mask. We also can't
2348 trust on the shape extension to be available
2349 (XShapeCombineRegion). So, compute the rectangle to draw
2351 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2355 xgcv
.clip_mask
= s
->img
->mask
;
2356 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2357 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2358 xgcv
.function
= GXcopy
;
2359 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2361 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2362 s
->slice
.x
, s
->slice
.y
,
2363 s
->slice
.width
, s
->slice
.height
, x
, y
);
2364 XSetClipMask (s
->display
, s
->gc
, None
);
2368 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2369 s
->slice
.x
, s
->slice
.y
,
2370 s
->slice
.width
, s
->slice
.height
, x
, y
);
2372 /* When the image has a mask, we can expect that at
2373 least part of a mouse highlight or a block cursor will
2374 be visible. If the image doesn't have a mask, make
2375 a block cursor visible by drawing a rectangle around
2376 the image. I believe it's looking better if we do
2377 nothing here for mouse-face. */
2378 if (s
->hl
== DRAW_CURSOR
)
2380 int r
= s
->img
->relief
;
2382 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2383 s
->slice
.width
+ r
*2 - 1,
2384 s
->slice
.height
+ r
*2 - 1);
2389 /* Draw a rectangle if image could not be loaded. */
2390 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2391 s
->slice
.width
- 1, s
->slice
.height
- 1);
2395 /* Draw part of the background of glyph string S. X, Y, W, and H
2396 give the rectangle to draw. */
2399 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2400 struct glyph_string
*s
;
2405 /* Fill background with a stipple pattern. */
2406 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2407 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2408 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2411 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2415 /* Draw image glyph string S.
2418 s->x +-------------------------
2421 | +-------------------------
2424 | | +-------------------
2430 x_draw_image_glyph_string (s
)
2431 struct glyph_string
*s
;
2433 int box_line_hwidth
= abs (s
->face
->box_line_width
);
2434 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2436 Pixmap pixmap
= None
;
2439 if (s
->slice
.y
== 0)
2440 height
-= box_line_vwidth
;
2441 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2442 height
-= box_line_vwidth
;
2444 /* Fill background with face under the image. Do it only if row is
2445 taller than image or if image has a clip mask to reduce
2447 s
->stippled_p
= s
->face
->stipple
!= 0;
2448 if (height
> s
->slice
.height
2452 || s
->img
->pixmap
== 0
2453 || s
->width
!= s
->background_width
)
2457 /* Create a pixmap as large as the glyph string. Fill it
2458 with the background color. Copy the image to it, using
2459 its mask. Copy the temporary pixmap to the display. */
2460 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2461 int depth
= DefaultDepthOfScreen (screen
);
2463 /* Create a pixmap as large as the glyph string. */
2464 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2465 s
->background_width
,
2468 /* Don't clip in the following because we're working on the
2470 XSetClipMask (s
->display
, s
->gc
, None
);
2472 /* Fill the pixmap with the background color/stipple. */
2475 /* Fill background with a stipple pattern. */
2476 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2477 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2478 0, 0, s
->background_width
, s
->height
);
2479 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2484 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2486 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2487 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2488 0, 0, s
->background_width
, s
->height
);
2489 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2497 if (s
->first_glyph
->left_box_line_p
2499 x
+= box_line_hwidth
;
2501 if (s
->slice
.y
== 0)
2502 y
+= box_line_vwidth
;
2504 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2507 s
->background_filled_p
= 1;
2510 /* Draw the foreground. */
2513 x_draw_image_foreground_1 (s
, pixmap
);
2514 x_set_glyph_string_clipping (s
);
2515 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2516 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2517 XFreePixmap (s
->display
, pixmap
);
2520 x_draw_image_foreground (s
);
2522 /* If we must draw a relief around the image, do it. */
2524 || s
->hl
== DRAW_IMAGE_RAISED
2525 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2526 x_draw_image_relief (s
);
2530 /* Draw stretch glyph string S. */
2533 x_draw_stretch_glyph_string (s
)
2534 struct glyph_string
*s
;
2536 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2537 s
->stippled_p
= s
->face
->stipple
!= 0;
2539 if (s
->hl
== DRAW_CURSOR
2540 && !x_stretch_cursor_p
)
2542 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2543 as wide as the stretch glyph. */
2544 int width
, background_width
= s
->background_width
;
2545 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2549 background_width
-= left_x
- x
;
2552 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2555 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2557 /* Clear rest using the GC of the original non-cursor face. */
2558 if (width
< background_width
)
2561 int w
= background_width
- width
, h
= s
->height
;
2566 if (s
->row
->mouse_face_p
2567 && cursor_in_mouse_face_p (s
->w
))
2569 x_set_mouse_face_gc (s
);
2575 get_glyph_string_clip_rect (s
, &r
);
2576 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2578 if (s
->face
->stipple
)
2580 /* Fill background with a stipple pattern. */
2581 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2582 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2583 XSetFillStyle (s
->display
, gc
, FillSolid
);
2588 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2589 XSetForeground (s
->display
, gc
, xgcv
.background
);
2590 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2591 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2595 else if (!s
->background_filled_p
)
2597 int background_width
= s
->background_width
;
2598 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2600 /* Don't draw into left margin, fringe or scrollbar area
2601 except for header line and mode line. */
2602 if (x
< left_x
&& !s
->row
->mode_line_p
)
2604 background_width
-= left_x
- x
;
2607 if (background_width
> 0)
2608 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2611 s
->background_filled_p
= 1;
2615 /* Draw glyph string S. */
2618 x_draw_glyph_string (s
)
2619 struct glyph_string
*s
;
2621 int relief_drawn_p
= 0;
2623 /* If S draws into the background of its successor, draw the
2624 background of the successor first so that S can draw into it.
2625 This makes S->next use XDrawString instead of XDrawImageString. */
2626 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2628 xassert (s
->next
->img
== NULL
);
2629 x_set_glyph_string_gc (s
->next
);
2630 x_set_glyph_string_clipping (s
->next
);
2631 x_draw_glyph_string_background (s
->next
, 1);
2634 /* Set up S->gc, set clipping and draw S. */
2635 x_set_glyph_string_gc (s
);
2637 /* Draw relief (if any) in advance for char/composition so that the
2638 glyph string can be drawn over it. */
2639 if (!s
->for_overlaps
2640 && s
->face
->box
!= FACE_NO_BOX
2641 && (s
->first_glyph
->type
== CHAR_GLYPH
2642 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2645 x_set_glyph_string_clipping (s
);
2646 x_draw_glyph_string_background (s
, 1);
2647 x_draw_glyph_string_box (s
);
2648 x_set_glyph_string_clipping (s
);
2652 x_set_glyph_string_clipping (s
);
2654 switch (s
->first_glyph
->type
)
2657 x_draw_image_glyph_string (s
);
2661 x_draw_stretch_glyph_string (s
);
2665 if (s
->for_overlaps
)
2666 s
->background_filled_p
= 1;
2668 x_draw_glyph_string_background (s
, 0);
2669 x_draw_glyph_string_foreground (s
);
2672 case COMPOSITE_GLYPH
:
2673 if (s
->for_overlaps
|| s
->gidx
> 0)
2674 s
->background_filled_p
= 1;
2676 x_draw_glyph_string_background (s
, 1);
2677 x_draw_composite_glyph_string_foreground (s
);
2684 if (!s
->for_overlaps
)
2686 /* Draw underline. */
2687 if (s
->face
->underline_p
)
2689 unsigned long tem
, h
;
2692 /* Get the underline thickness. Default is 1 pixel. */
2693 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
2696 y
= s
->y
+ s
->height
- h
;
2697 if (!x_underline_at_descent_line
)
2699 /* Get the underline position. This is the recommended
2700 vertical offset in pixels from the baseline to the top of
2701 the underline. This is a signed value according to the
2702 specs, and its default is
2704 ROUND ((maximum descent) / 2), with
2705 ROUND(x) = floor (x + 0.5) */
2707 if (x_use_underline_position_properties
2708 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
2709 y
= s
->ybase
+ (long) tem
;
2710 else if (s
->face
->font
)
2711 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
2714 if (s
->face
->underline_defaulted_p
)
2715 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2716 s
->x
, y
, s
->background_width
, h
);
2720 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2721 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2722 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2723 s
->x
, y
, s
->background_width
, h
);
2724 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2728 /* Draw overline. */
2729 if (s
->face
->overline_p
)
2731 unsigned long dy
= 0, h
= 1;
2733 if (s
->face
->overline_color_defaulted_p
)
2734 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2735 s
->background_width
, h
);
2739 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2740 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2741 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2742 s
->background_width
, h
);
2743 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2747 /* Draw strike-through. */
2748 if (s
->face
->strike_through_p
)
2750 unsigned long h
= 1;
2751 unsigned long dy
= (s
->height
- h
) / 2;
2753 if (s
->face
->strike_through_color_defaulted_p
)
2754 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2759 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2760 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2761 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2763 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2767 /* Draw relief if not yet drawn. */
2768 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2769 x_draw_glyph_string_box (s
);
2772 /* Reset clipping. */
2773 XSetClipMask (s
->display
, s
->gc
, None
);
2776 /* Shift display to make room for inserted glyphs. */
2779 x_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2781 int x
, y
, width
, height
, shift_by
;
2783 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2784 f
->output_data
.x
->normal_gc
,
2785 x
, y
, width
, height
,
2789 /* Delete N glyphs at the nominal cursor position. Not implemented
2800 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2801 If they are <= 0, this is probably an error. */
2804 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
2811 xassert (width
> 0 && height
> 0);
2812 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2816 /* Clear entire frame. If updating_frame is non-null, clear that
2817 frame. Otherwise clear the selected frame. */
2827 f
= SELECTED_FRAME ();
2829 /* Clearing the frame will erase any cursor, so mark them all as no
2831 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2832 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2833 output_cursor
.x
= -1;
2835 /* We don't set the output cursor here because there will always
2836 follow an explicit cursor_to. */
2838 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2840 /* We have to clear the scroll bars, too. If we have changed
2841 colors or something like that, then they should be notified. */
2842 x_scroll_bar_clear (f
);
2844 XFlush (FRAME_X_DISPLAY (f
));
2851 /* Invert the middle quarter of the frame for .15 sec. */
2853 /* We use the select system call to do the waiting, so we have to make
2854 sure it's available. If it isn't, we just won't do visual bells. */
2856 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2859 /* Subtract the `struct timeval' values X and Y, storing the result in
2860 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2863 timeval_subtract (result
, x
, y
)
2864 struct timeval
*result
, x
, y
;
2866 /* Perform the carry for the later subtraction by updating y. This
2867 is safer because on some systems the tv_sec member is unsigned. */
2868 if (x
.tv_usec
< y
.tv_usec
)
2870 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2871 y
.tv_usec
-= 1000000 * nsec
;
2875 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2877 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2878 y
.tv_usec
+= 1000000 * nsec
;
2882 /* Compute the time remaining to wait. tv_usec is certainly
2884 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2885 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2887 /* Return indication of whether the result should be considered
2889 return x
.tv_sec
< y
.tv_sec
;
2901 /* Create a GC that will use the GXxor function to flip foreground
2902 pixels into background pixels. */
2906 values
.function
= GXxor
;
2907 values
.foreground
= (f
->output_data
.x
->foreground_pixel
2908 ^ f
->output_data
.x
->background_pixel
);
2910 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2911 GCFunction
| GCForeground
, &values
);
2915 /* Get the height not including a menu bar widget. */
2916 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
2917 /* Height of each line to flash. */
2918 int flash_height
= FRAME_LINE_HEIGHT (f
);
2919 /* These will be the left and right margins of the rectangles. */
2920 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
2921 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
2925 /* Don't flash the area between a scroll bar and the frame
2926 edge it is next to. */
2927 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
2929 case vertical_scroll_bar_left
:
2930 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2933 case vertical_scroll_bar_right
:
2934 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2941 width
= flash_right
- flash_left
;
2943 /* If window is tall, flash top and bottom line. */
2944 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2946 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2948 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2949 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
2950 width
, flash_height
);
2951 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2953 (height
- flash_height
2954 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2955 width
, flash_height
);
2958 /* If it is short, flash it all. */
2959 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2960 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
2961 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
2966 struct timeval wakeup
;
2968 EMACS_GET_TIME (wakeup
);
2970 /* Compute time to wait until, propagating carry from usecs. */
2971 wakeup
.tv_usec
+= 150000;
2972 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
2973 wakeup
.tv_usec
%= 1000000;
2975 /* Keep waiting until past the time wakeup or any input gets
2977 while (! detect_input_pending ())
2979 struct timeval current
;
2980 struct timeval timeout
;
2982 EMACS_GET_TIME (current
);
2984 /* Break if result would be negative. */
2985 if (timeval_subtract (¤t
, wakeup
, current
))
2988 /* How long `select' should wait. */
2990 timeout
.tv_usec
= 10000;
2992 /* Try to wait that long--but we might wake up sooner. */
2993 select (0, NULL
, NULL
, NULL
, &timeout
);
2997 /* If window is tall, flash top and bottom line. */
2998 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3000 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3002 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3003 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
3004 width
, flash_height
);
3005 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3007 (height
- flash_height
3008 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3009 width
, flash_height
);
3012 /* If it is short, flash it all. */
3013 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3014 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3015 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3017 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3025 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3028 /* Make audible bell. */
3033 struct frame
*f
= SELECTED_FRAME ();
3035 if (FRAME_X_DISPLAY (f
))
3037 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3044 XBell (FRAME_X_DISPLAY (f
), 0);
3045 XFlush (FRAME_X_DISPLAY (f
));
3052 /* Specify how many text lines, from the top of the window,
3053 should be affected by insert-lines and delete-lines operations.
3054 This, and those operations, are used only within an update
3055 that is bounded by calls to x_update_begin and x_update_end. */
3058 XTset_terminal_window (n
)
3061 /* This function intentionally left blank. */
3066 /***********************************************************************
3068 ***********************************************************************/
3070 /* Perform an insert-lines or delete-lines operation, inserting N
3071 lines or deleting -N lines at vertical position VPOS. */
3074 x_ins_del_lines (vpos
, n
)
3081 /* Scroll part of the display as described by RUN. */
3084 x_scroll_run (w
, run
)
3088 struct frame
*f
= XFRAME (w
->frame
);
3089 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3091 /* Get frame-relative bounding box of the text display area of W,
3092 without mode lines. Include in this box the left and right
3094 window_box (w
, -1, &x
, &y
, &width
, &height
);
3096 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3097 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3098 bottom_y
= y
+ height
;
3102 /* Scrolling up. Make sure we don't copy part of the mode
3103 line at the bottom. */
3104 if (from_y
+ run
->height
> bottom_y
)
3105 height
= bottom_y
- from_y
;
3107 height
= run
->height
;
3111 /* Scolling down. Make sure we don't copy over the mode line.
3113 if (to_y
+ run
->height
> bottom_y
)
3114 height
= bottom_y
- to_y
;
3116 height
= run
->height
;
3121 /* Cursor off. Will be switched on again in x_update_window_end. */
3125 XCopyArea (FRAME_X_DISPLAY (f
),
3126 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3127 f
->output_data
.x
->normal_gc
,
3137 /***********************************************************************
3139 ***********************************************************************/
3146 /* We used to only do this if Vx_no_window_manager was non-nil, but
3147 the ICCCM (section 4.1.6) says that the window's border pixmap
3148 and border pixel are window attributes which are "private to the
3149 client", so we can always change it to whatever we want. */
3151 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3152 f
->output_data
.x
->border_pixel
);
3154 x_update_cursor (f
, 1);
3158 frame_unhighlight (f
)
3161 /* We used to only do this if Vx_no_window_manager was non-nil, but
3162 the ICCCM (section 4.1.6) says that the window's border pixmap
3163 and border pixel are window attributes which are "private to the
3164 client", so we can always change it to whatever we want. */
3166 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3167 f
->output_data
.x
->border_tile
);
3169 x_update_cursor (f
, 1);
3172 /* The focus has changed. Update the frames as necessary to reflect
3173 the new situation. Note that we can't change the selected frame
3174 here, because the Lisp code we are interrupting might become confused.
3175 Each event gets marked with the frame in which it occurred, so the
3176 Lisp code can tell when the switch took place by examining the events. */
3179 x_new_focus_frame (dpyinfo
, frame
)
3180 struct x_display_info
*dpyinfo
;
3181 struct frame
*frame
;
3183 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3185 if (frame
!= dpyinfo
->x_focus_frame
)
3187 /* Set this before calling other routines, so that they see
3188 the correct value of x_focus_frame. */
3189 dpyinfo
->x_focus_frame
= frame
;
3191 if (old_focus
&& old_focus
->auto_lower
)
3192 x_lower_frame (old_focus
);
3195 selected_frame
= frame
;
3196 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
3198 Fselect_window (selected_frame
->selected_window
, Qnil
);
3199 choose_minibuf_frame ();
3202 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3203 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3205 pending_autoraise_frame
= 0;
3208 x_frame_rehighlight (dpyinfo
);
3211 /* Handle FocusIn and FocusOut state changes for FRAME.
3212 If FRAME has focus and there exists more than one frame, puts
3213 a FOCUS_IN_EVENT into *BUFP. */
3216 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
3219 struct x_display_info
*dpyinfo
;
3220 struct frame
*frame
;
3221 struct input_event
*bufp
;
3223 if (type
== FocusIn
)
3225 if (dpyinfo
->x_focus_event_frame
!= frame
)
3227 x_new_focus_frame (dpyinfo
, frame
);
3228 dpyinfo
->x_focus_event_frame
= frame
;
3230 /* Don't stop displaying the initial startup message
3231 for a switch-frame event we don't need. */
3232 if (GC_NILP (Vterminal_frame
)
3233 && GC_CONSP (Vframe_list
)
3234 && !GC_NILP (XCDR (Vframe_list
)))
3236 bufp
->kind
= FOCUS_IN_EVENT
;
3237 XSETFRAME (bufp
->frame_or_window
, frame
);
3241 frame
->output_data
.x
->focus_state
|= state
;
3244 if (FRAME_XIC (frame
))
3245 XSetICFocus (FRAME_XIC (frame
));
3248 else if (type
== FocusOut
)
3250 frame
->output_data
.x
->focus_state
&= ~state
;
3252 if (dpyinfo
->x_focus_event_frame
== frame
)
3254 dpyinfo
->x_focus_event_frame
= 0;
3255 x_new_focus_frame (dpyinfo
, 0);
3259 if (FRAME_XIC (frame
))
3260 XUnsetICFocus (FRAME_XIC (frame
));
3265 /* The focus may have changed. Figure out if it is a real focus change,
3266 by checking both FocusIn/Out and Enter/LeaveNotify events.
3268 Returns FOCUS_IN_EVENT event in *BUFP. */
3271 x_detect_focus_change (dpyinfo
, event
, bufp
)
3272 struct x_display_info
*dpyinfo
;
3274 struct input_event
*bufp
;
3276 struct frame
*frame
;
3278 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3282 switch (event
->type
)
3287 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3289 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3291 if (event
->xcrossing
.detail
!= NotifyInferior
3292 && event
->xcrossing
.focus
3293 && ! (focus_state
& FOCUS_EXPLICIT
))
3294 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3296 dpyinfo
, frame
, bufp
);
3302 x_focus_changed (event
->type
,
3303 (event
->xfocus
.detail
== NotifyPointer
?
3304 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3305 dpyinfo
, frame
, bufp
);
3311 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3314 x_mouse_leave (dpyinfo
)
3315 struct x_display_info
*dpyinfo
;
3317 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3320 /* The focus has changed, or we have redirected a frame's focus to
3321 another frame (this happens when a frame uses a surrogate
3322 mini-buffer frame). Shift the highlight as appropriate.
3324 The FRAME argument doesn't necessarily have anything to do with which
3325 frame is being highlighted or un-highlighted; we only use it to find
3326 the appropriate X display info. */
3329 XTframe_rehighlight (frame
)
3330 struct frame
*frame
;
3332 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3336 x_frame_rehighlight (dpyinfo
)
3337 struct x_display_info
*dpyinfo
;
3339 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3341 if (dpyinfo
->x_focus_frame
)
3343 dpyinfo
->x_highlight_frame
3344 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3345 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3346 : dpyinfo
->x_focus_frame
);
3347 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3349 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3350 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3354 dpyinfo
->x_highlight_frame
= 0;
3356 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3359 frame_unhighlight (old_highlight
);
3360 if (dpyinfo
->x_highlight_frame
)
3361 frame_highlight (dpyinfo
->x_highlight_frame
);
3367 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3369 /* Initialize mode_switch_bit and modifier_meaning. */
3371 x_find_modifier_meanings (dpyinfo
)
3372 struct x_display_info
*dpyinfo
;
3374 int min_code
, max_code
;
3377 XModifierKeymap
*mods
;
3379 dpyinfo
->meta_mod_mask
= 0;
3380 dpyinfo
->shift_lock_mask
= 0;
3381 dpyinfo
->alt_mod_mask
= 0;
3382 dpyinfo
->super_mod_mask
= 0;
3383 dpyinfo
->hyper_mod_mask
= 0;
3386 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3388 min_code
= dpyinfo
->display
->min_keycode
;
3389 max_code
= dpyinfo
->display
->max_keycode
;
3392 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3393 min_code
, max_code
- min_code
+ 1,
3395 mods
= XGetModifierMapping (dpyinfo
->display
);
3397 /* Scan the modifier table to see which modifier bits the Meta and
3398 Alt keysyms are on. */
3400 int row
, col
; /* The row and column in the modifier table. */
3401 int found_alt_or_meta
;
3403 for (row
= 3; row
< 8; row
++)
3405 found_alt_or_meta
= 0;
3406 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3408 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3410 /* Zeroes are used for filler. Skip them. */
3414 /* Are any of this keycode's keysyms a meta key? */
3418 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3420 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3426 found_alt_or_meta
= 1;
3427 dpyinfo
->meta_mod_mask
|= (1 << row
);
3432 found_alt_or_meta
= 1;
3433 dpyinfo
->alt_mod_mask
|= (1 << row
);
3438 if (!found_alt_or_meta
)
3439 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3440 code_col
= syms_per_code
;
3441 col
= mods
->max_keypermod
;
3446 if (!found_alt_or_meta
)
3447 dpyinfo
->super_mod_mask
|= (1 << row
);
3448 code_col
= syms_per_code
;
3449 col
= mods
->max_keypermod
;
3453 /* Ignore this if it's not on the lock modifier. */
3454 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3455 dpyinfo
->shift_lock_mask
= LockMask
;
3456 code_col
= syms_per_code
;
3457 col
= mods
->max_keypermod
;
3466 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3467 if (! dpyinfo
->meta_mod_mask
)
3469 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3470 dpyinfo
->alt_mod_mask
= 0;
3473 /* If some keys are both alt and meta,
3474 make them just meta, not alt. */
3475 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3477 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3480 XFree ((char *) syms
);
3481 XFreeModifiermap (mods
);
3484 /* Convert between the modifier bits X uses and the modifier bits
3488 x_x_to_emacs_modifiers (dpyinfo
, state
)
3489 struct x_display_info
*dpyinfo
;
3492 EMACS_UINT mod_meta
= meta_modifier
;
3493 EMACS_UINT mod_alt
= alt_modifier
;
3494 EMACS_UINT mod_hyper
= hyper_modifier
;
3495 EMACS_UINT mod_super
= super_modifier
;
3498 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3499 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3500 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3501 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3502 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3503 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3504 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3505 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3508 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3509 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3510 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3511 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3512 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3513 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3517 x_emacs_to_x_modifiers (dpyinfo
, state
)
3518 struct x_display_info
*dpyinfo
;
3521 EMACS_UINT mod_meta
= meta_modifier
;
3522 EMACS_UINT mod_alt
= alt_modifier
;
3523 EMACS_UINT mod_hyper
= hyper_modifier
;
3524 EMACS_UINT mod_super
= super_modifier
;
3528 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3529 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3530 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3531 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3532 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3533 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3534 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3535 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3538 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3539 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3540 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3541 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3542 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3543 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3546 /* Convert a keysym to its name. */
3549 x_get_keysym_name (keysym
)
3555 value
= XKeysymToString (keysym
);
3563 /* Mouse clicks and mouse movement. Rah. */
3565 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3567 If the event is a button press, then note that we have grabbed
3571 construct_mouse_click (result
, event
, f
)
3572 struct input_event
*result
;
3573 XButtonEvent
*event
;
3576 /* Make the event type NO_EVENT; we'll change that when we decide
3578 result
->kind
= MOUSE_CLICK_EVENT
;
3579 result
->code
= event
->button
- Button1
;
3580 result
->timestamp
= event
->time
;
3581 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3583 | (event
->type
== ButtonRelease
3587 XSETINT (result
->x
, event
->x
);
3588 XSETINT (result
->y
, event
->y
);
3589 XSETFRAME (result
->frame_or_window
, f
);
3595 /* Function to report a mouse movement to the mainstream Emacs code.
3596 The input handler calls this.
3598 We have received a mouse movement event, which is given in *event.
3599 If the mouse is over a different glyph than it was last time, tell
3600 the mainstream emacs code by setting mouse_moved. If not, ask for
3601 another motion event, so we can check again the next time it moves. */
3603 static XMotionEvent last_mouse_motion_event
;
3604 static Lisp_Object last_mouse_motion_frame
;
3607 note_mouse_movement (frame
, event
)
3609 XMotionEvent
*event
;
3611 last_mouse_movement_time
= event
->time
;
3612 last_mouse_motion_event
= *event
;
3613 XSETFRAME (last_mouse_motion_frame
, frame
);
3615 if (!FRAME_X_OUTPUT (frame
))
3618 if (event
->window
!= FRAME_X_WINDOW (frame
))
3620 frame
->mouse_moved
= 1;
3621 last_mouse_scroll_bar
= Qnil
;
3622 note_mouse_highlight (frame
, -1, -1);
3623 last_mouse_glyph_frame
= 0;
3628 /* Has the mouse moved off the glyph it was on at the last sighting? */
3629 if (frame
!= last_mouse_glyph_frame
3630 || event
->x
< last_mouse_glyph
.x
3631 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3632 || event
->y
< last_mouse_glyph
.y
3633 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3635 frame
->mouse_moved
= 1;
3636 last_mouse_scroll_bar
= Qnil
;
3637 note_mouse_highlight (frame
, event
->x
, event
->y
);
3638 /* Remember which glyph we're now on. */
3639 remember_mouse_glyph (frame
, event
->x
, event
->y
, &last_mouse_glyph
);
3640 last_mouse_glyph_frame
= frame
;
3648 /************************************************************************
3650 ************************************************************************/
3653 redo_mouse_highlight ()
3655 if (!NILP (last_mouse_motion_frame
)
3656 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3657 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3658 last_mouse_motion_event
.x
,
3659 last_mouse_motion_event
.y
);
3664 /* Return the current position of the mouse.
3665 *FP should be a frame which indicates which display to ask about.
3667 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3668 and *PART to the frame, window, and scroll bar part that the mouse
3669 is over. Set *X and *Y to the portion and whole of the mouse's
3670 position on the scroll bar.
3672 If the mouse movement started elsewhere, set *FP to the frame the
3673 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3676 Set *TIME to the server time-stamp for the time at which the mouse
3677 was at this position.
3679 Don't store anything if we don't have a valid set of values to report.
3681 This clears the mouse_moved flag, so we can wait for the next mouse
3685 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3688 Lisp_Object
*bar_window
;
3689 enum scroll_bar_part
*part
;
3691 unsigned long *time
;
3697 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3698 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3704 Window dummy_window
;
3707 Lisp_Object frame
, tail
;
3709 /* Clear the mouse-moved flag for every frame on this display. */
3710 FOR_EACH_FRAME (tail
, frame
)
3711 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3712 XFRAME (frame
)->mouse_moved
= 0;
3714 last_mouse_scroll_bar
= Qnil
;
3716 /* Figure out which root window we're on. */
3717 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3718 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3720 /* The root window which contains the pointer. */
3723 /* Trash which we can't trust if the pointer is on
3724 a different screen. */
3727 /* The position on that root window. */
3730 /* More trash we can't trust. */
3733 /* Modifier keys and pointer buttons, about which
3735 (unsigned int *) &dummy
);
3737 /* Now we have a position on the root; find the innermost window
3738 containing the pointer. */
3742 int parent_x
= 0, parent_y
= 0;
3746 /* XTranslateCoordinates can get errors if the window
3747 structure is changing at the same time this function
3748 is running. So at least we must not crash from them. */
3750 x_catch_errors (FRAME_X_DISPLAY (*fp
));
3752 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3753 && FRAME_LIVE_P (last_mouse_frame
))
3755 /* If mouse was grabbed on a frame, give coords for that frame
3756 even if the mouse is now outside it. */
3757 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3759 /* From-window, to-window. */
3760 root
, FRAME_X_WINDOW (last_mouse_frame
),
3762 /* From-position, to-position. */
3763 root_x
, root_y
, &win_x
, &win_y
,
3767 f1
= last_mouse_frame
;
3773 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3775 /* From-window, to-window. */
3778 /* From-position, to-position. */
3779 root_x
, root_y
, &win_x
, &win_y
,
3784 if (child
== None
|| child
== win
)
3792 /* Now we know that:
3793 win is the innermost window containing the pointer
3794 (XTC says it has no child containing the pointer),
3795 win_x and win_y are the pointer's position in it
3796 (XTC did this the last time through), and
3797 parent_x and parent_y are the pointer's position in win's parent.
3798 (They are what win_x and win_y were when win was child.
3799 If win is the root window, it has no parent, and
3800 parent_{x,y} are invalid, but that's okay, because we'll
3801 never use them in that case.) */
3803 /* Is win one of our frames? */
3804 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3806 #ifdef USE_X_TOOLKIT
3807 /* If we end up with the menu bar window, say it's not
3810 && f1
->output_data
.x
->menubar_widget
3811 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3813 #endif /* USE_X_TOOLKIT */
3816 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3819 x_uncatch_errors ();
3821 /* If not, is it one of our scroll bars? */
3824 struct scroll_bar
*bar
;
3826 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3830 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3836 if (f1
== 0 && insist
> 0)
3837 f1
= SELECTED_FRAME ();
3841 /* Ok, we found a frame. Store all the values.
3842 last_mouse_glyph is a rectangle used to reduce the
3843 generation of mouse events. To not miss any motion
3844 events, we must divide the frame into rectangles of the
3845 size of the smallest character that could be displayed
3846 on it, i.e. into the same rectangles that matrices on
3847 the frame are divided into. */
3849 remember_mouse_glyph (f1
, win_x
, win_y
, &last_mouse_glyph
);
3850 last_mouse_glyph_frame
= f1
;
3855 XSETINT (*x
, win_x
);
3856 XSETINT (*y
, win_y
);
3857 *time
= last_mouse_movement_time
;
3867 /***********************************************************************
3869 ***********************************************************************/
3871 /* Scroll bar support. */
3873 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3875 This can be called in GC, so we have to make sure to strip off mark
3878 static struct scroll_bar
*
3879 x_window_to_scroll_bar (display
, window_id
)
3885 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3886 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3887 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
3889 for (tail
= Vframe_list
;
3890 XGCTYPE (tail
) == Lisp_Cons
;
3893 Lisp_Object frame
, bar
, condemned
;
3895 frame
= XCAR (tail
);
3896 /* All elements of Vframe_list should be frames. */
3897 if (! GC_FRAMEP (frame
))
3900 /* Scan this frame's scroll bar list for a scroll bar with the
3902 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3903 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3904 /* This trick allows us to search both the ordinary and
3905 condemned scroll bar lists with one loop. */
3906 ! GC_NILP (bar
) || (bar
= condemned
,
3909 bar
= XSCROLL_BAR (bar
)->next
)
3910 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
&&
3911 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
3912 return XSCROLL_BAR (bar
);
3919 #if defined USE_LUCID
3921 /* Return the Lucid menu bar WINDOW is part of. Return null
3922 if WINDOW is not part of a menu bar. */
3925 x_window_to_menu_bar (window
)
3930 for (tail
= Vframe_list
;
3931 XGCTYPE (tail
) == Lisp_Cons
;
3934 Lisp_Object frame
= XCAR (tail
);
3935 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
3937 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
3944 #endif /* USE_LUCID */
3947 /************************************************************************
3949 ************************************************************************/
3951 #ifdef USE_TOOLKIT_SCROLL_BARS
3953 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
3954 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
3955 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
3956 struct scroll_bar
*));
3957 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
3961 /* Lisp window being scrolled. Set when starting to interact with
3962 a toolkit scroll bar, reset to nil when ending the interaction. */
3964 static Lisp_Object window_being_scrolled
;
3966 /* Last scroll bar part sent in xm_scroll_callback. */
3968 static int last_scroll_bar_part
;
3970 /* Whether this is an Xaw with arrow-scrollbars. This should imply
3971 that movements of 1/20 of the screen size are mapped to up/down. */
3974 /* Id of action hook installed for scroll bars. */
3976 static XtActionHookId action_hook_id
;
3978 static Boolean xaw3d_arrow_scroll
;
3980 /* Whether the drag scrolling maintains the mouse at the top of the
3981 thumb. If not, resizing the thumb needs to be done more carefully
3982 to avoid jerkyness. */
3984 static Boolean xaw3d_pick_top
;
3986 /* Action hook installed via XtAppAddActionHook when toolkit scroll
3987 bars are used.. The hook is responsible for detecting when
3988 the user ends an interaction with the scroll bar, and generates
3989 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
3992 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
3995 XtPointer client_data
;
3999 Cardinal
*num_params
;
4005 scroll_bar_p
= XmIsScrollBar (widget
);
4006 end_action
= "Release";
4007 #else /* !USE_MOTIF i.e. use Xaw */
4008 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4009 end_action
= "EndScroll";
4010 #endif /* USE_MOTIF */
4013 && strcmp (action_name
, end_action
) == 0
4014 && WINDOWP (window_being_scrolled
))
4018 x_send_scroll_bar_event (window_being_scrolled
,
4019 scroll_bar_end_scroll
, 0, 0);
4020 w
= XWINDOW (window_being_scrolled
);
4022 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4024 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4025 /* The thumb size is incorrect while dragging: fix it. */
4026 set_vertical_scroll_bar (w
);
4028 window_being_scrolled
= Qnil
;
4029 last_scroll_bar_part
= -1;
4031 /* Xt timeouts no longer needed. */
4032 toolkit_scroll_bar_interaction
= 0;
4035 #endif /* not USE_GTK */
4037 /* A vector of windows used for communication between
4038 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4040 static struct window
**scroll_bar_windows
;
4041 static int scroll_bar_windows_size
;
4044 /* Send a client message with message type Xatom_Scrollbar for a
4045 scroll action to the frame of WINDOW. PART is a value identifying
4046 the part of the scroll bar that was clicked on. PORTION is the
4047 amount to scroll of a whole of WHOLE. */
4050 x_send_scroll_bar_event (window
, part
, portion
, whole
)
4052 int part
, portion
, whole
;
4055 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4056 struct window
*w
= XWINDOW (window
);
4057 struct frame
*f
= XFRAME (w
->frame
);
4062 /* Construct a ClientMessage event to send to the frame. */
4063 ev
->type
= ClientMessage
;
4064 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4065 ev
->display
= FRAME_X_DISPLAY (f
);
4066 ev
->window
= FRAME_X_WINDOW (f
);
4069 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4070 not enough to store a pointer or Lisp_Object on a 64 bit system.
4071 So, store the window in scroll_bar_windows and pass the index
4072 into that array in the event. */
4073 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4074 if (scroll_bar_windows
[i
] == NULL
)
4077 if (i
== scroll_bar_windows_size
)
4079 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4080 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4081 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4083 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4085 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
4086 scroll_bar_windows_size
= new_size
;
4089 scroll_bar_windows
[i
] = w
;
4090 ev
->data
.l
[0] = (long) i
;
4091 ev
->data
.l
[1] = (long) part
;
4092 ev
->data
.l
[2] = (long) 0;
4093 ev
->data
.l
[3] = (long) portion
;
4094 ev
->data
.l
[4] = (long) whole
;
4096 /* Make Xt timeouts work while the scroll bar is active. */
4097 toolkit_scroll_bar_interaction
= 1;
4098 #ifdef USE_X_TOOLKIT
4099 x_activate_timeout_atimer ();
4102 /* Setting the event mask to zero means that the message will
4103 be sent to the client that created the window, and if that
4104 window no longer exists, no event will be sent. */
4105 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4110 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4114 x_scroll_bar_to_input_event (event
, ievent
)
4116 struct input_event
*ievent
;
4118 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4123 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4124 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4126 XSETWINDOW (window
, w
);
4127 f
= XFRAME (w
->frame
);
4129 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4130 ievent
->frame_or_window
= window
;
4133 ievent
->timestamp
= CurrentTime
;
4135 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4137 ievent
->part
= ev
->data
.l
[1];
4138 ievent
->code
= ev
->data
.l
[2];
4139 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4140 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4141 ievent
->modifiers
= 0;
4147 /* Minimum and maximum values used for Motif scroll bars. */
4149 #define XM_SB_MAX 10000000
4152 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4153 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4154 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4157 xm_scroll_callback (widget
, client_data
, call_data
)
4159 XtPointer client_data
, call_data
;
4161 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4162 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4163 int part
= -1, whole
= 0, portion
= 0;
4167 case XmCR_DECREMENT
:
4168 bar
->dragging
= Qnil
;
4169 part
= scroll_bar_up_arrow
;
4172 case XmCR_INCREMENT
:
4173 bar
->dragging
= Qnil
;
4174 part
= scroll_bar_down_arrow
;
4177 case XmCR_PAGE_DECREMENT
:
4178 bar
->dragging
= Qnil
;
4179 part
= scroll_bar_above_handle
;
4182 case XmCR_PAGE_INCREMENT
:
4183 bar
->dragging
= Qnil
;
4184 part
= scroll_bar_below_handle
;
4188 bar
->dragging
= Qnil
;
4189 part
= scroll_bar_to_top
;
4192 case XmCR_TO_BOTTOM
:
4193 bar
->dragging
= Qnil
;
4194 part
= scroll_bar_to_bottom
;
4201 /* Get the slider size. */
4203 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4206 whole
= XM_SB_MAX
- slider_size
;
4207 portion
= min (cs
->value
, whole
);
4208 part
= scroll_bar_handle
;
4209 bar
->dragging
= make_number (cs
->value
);
4213 case XmCR_VALUE_CHANGED
:
4219 window_being_scrolled
= bar
->window
;
4220 last_scroll_bar_part
= part
;
4221 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4226 #else /* !USE_MOTIF, i.e. Xaw or GTK */
4228 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4229 bar widget. DATA is a pointer to the scroll_bar structure. */
4232 xg_scroll_callback (widget
, data
)
4236 struct scroll_bar
*bar
= (struct scroll_bar
*) data
;
4242 int part
= -1, whole
= 0, portion
= 0;
4243 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (widget
));
4245 position
= gtk_adjustment_get_value (adj
);
4247 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
4250 p
= (gdouble
*) xmalloc (sizeof (gdouble
));
4252 g_object_set_data (G_OBJECT (widget
), XG_LAST_SB_DATA
, p
);
4258 if (xg_ignore_gtk_scrollbar
) return;
4260 diff
= (int) (position
- previous
);
4262 if (diff
== (int) adj
->step_increment
)
4264 part
= scroll_bar_down_arrow
;
4265 bar
->dragging
= Qnil
;
4267 else if (-diff
== (int) adj
->step_increment
)
4269 part
= scroll_bar_up_arrow
;
4270 bar
->dragging
= Qnil
;
4272 else if (diff
== (int) adj
->page_increment
)
4274 part
= scroll_bar_below_handle
;
4275 bar
->dragging
= Qnil
;
4277 else if (-diff
== (int) adj
->page_increment
)
4279 part
= scroll_bar_above_handle
;
4280 bar
->dragging
= Qnil
;
4284 part
= scroll_bar_handle
;
4285 whole
= adj
->upper
- adj
->page_size
;
4286 portion
= min ((int)position
, whole
);
4287 bar
->dragging
= make_number ((int)portion
);
4292 window_being_scrolled
= bar
->window
;
4293 last_scroll_bar_part
= part
;
4294 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4298 #else /* not USE_GTK */
4300 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4301 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4302 scroll bar struct. CALL_DATA is a pointer to a float saying where
4306 xaw_jump_callback (widget
, client_data
, call_data
)
4308 XtPointer client_data
, call_data
;
4310 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4311 float top
= *(float *) call_data
;
4313 int whole
, portion
, height
;
4316 /* Get the size of the thumb, a value between 0 and 1. */
4318 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4322 portion
= shown
< 1 ? top
* whole
: 0;
4324 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
4325 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4326 the bottom, so we force the scrolling whenever we see that we're
4327 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4328 we try to ensure that we always stay two pixels away from the
4330 part
= scroll_bar_down_arrow
;
4332 part
= scroll_bar_handle
;
4334 window_being_scrolled
= bar
->window
;
4335 bar
->dragging
= make_number (portion
);
4336 last_scroll_bar_part
= part
;
4337 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4341 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4342 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4343 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4344 the scroll bar. CALL_DATA is an integer specifying the action that
4345 has taken place. Its magnitude is in the range 0..height of the
4346 scroll bar. Negative values mean scroll towards buffer start.
4347 Values < height of scroll bar mean line-wise movement. */
4350 xaw_scroll_callback (widget
, client_data
, call_data
)
4352 XtPointer client_data
, call_data
;
4354 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4355 /* The position really is stored cast to a pointer. */
4356 int position
= (long) call_data
;
4360 /* Get the height of the scroll bar. */
4362 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4365 if (abs (position
) >= height
)
4366 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4368 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4369 it maps line-movement to call_data = max(5, height/20). */
4370 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
4371 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4373 part
= scroll_bar_move_ratio
;
4375 window_being_scrolled
= bar
->window
;
4376 bar
->dragging
= Qnil
;
4377 last_scroll_bar_part
= part
;
4378 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4381 #endif /* not USE_GTK */
4382 #endif /* not USE_MOTIF */
4384 #define SCROLL_BAR_NAME "verticalScrollBar"
4386 /* Create the widget for scroll bar BAR on frame F. Record the widget
4387 and X window of the scroll bar in BAR. */
4391 x_create_toolkit_scroll_bar (f
, bar
)
4393 struct scroll_bar
*bar
;
4395 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4398 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4403 #else /* not USE_GTK */
4406 x_create_toolkit_scroll_bar (f
, bar
)
4408 struct scroll_bar
*bar
;
4414 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4415 unsigned long pixel
;
4420 /* Set resources. Create the widget. */
4421 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4422 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4423 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4424 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4425 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4426 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4427 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4429 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4432 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4436 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4439 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4443 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4444 scroll_bar_name
, av
, ac
);
4446 /* Add one callback for everything that can happen. */
4447 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4449 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4451 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4453 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4455 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4457 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4459 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4462 /* Realize the widget. Only after that is the X window created. */
4463 XtRealizeWidget (widget
);
4465 /* Set the cursor to an arrow. I didn't find a resource to do that.
4466 And I'm wondering why it hasn't an arrow cursor by default. */
4467 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4468 f
->output_data
.x
->nontext_cursor
);
4470 #else /* !USE_MOTIF i.e. use Xaw */
4472 /* Set resources. Create the widget. The background of the
4473 Xaw3d scroll bar widget is a little bit light for my taste.
4474 We don't alter it here to let users change it according
4475 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4476 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4477 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4478 /* For smoother scrolling with Xaw3d -sm */
4479 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4481 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4484 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4488 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4491 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4495 /* Top/bottom shadow colors. */
4497 /* Allocate them, if necessary. */
4498 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4500 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4501 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4502 &pixel
, 1.2, 0x8000))
4504 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4506 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4508 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4509 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4510 &pixel
, 0.6, 0x4000))
4512 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4515 #ifdef XtNbeNiceToColormap
4516 /* Tell the toolkit about them. */
4517 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4518 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4519 /* We tried to allocate a color for the top/bottom shadow, and
4520 failed, so tell Xaw3d to use dithering instead. */
4522 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
4526 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4527 be more consistent with other emacs 3d colors, and since Xaw3d is
4528 not good at dealing with allocation failure. */
4530 /* This tells Xaw3d to use real colors instead of dithering for
4532 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4535 /* Specify the colors. */
4536 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4539 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4542 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4545 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4551 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4552 f
->output_data
.x
->edit_widget
, av
, ac
);
4556 char *val
= initial
;
4557 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4558 #ifdef XtNarrowScrollbars
4559 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4561 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4562 if (xaw3d_arrow_scroll
|| val
== initial
)
4563 { /* ARROW_SCROLL */
4564 xaw3d_arrow_scroll
= True
;
4565 /* Isn't that just a personal preference ? --Stef */
4566 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4570 /* Define callbacks. */
4571 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4572 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4575 /* Realize the widget. Only after that is the X window created. */
4576 XtRealizeWidget (widget
);
4578 #endif /* !USE_MOTIF */
4580 /* Install an action hook that lets us detect when the user
4581 finishes interacting with a scroll bar. */
4582 if (action_hook_id
== 0)
4583 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4585 /* Remember X window and widget in the scroll bar vector. */
4586 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4587 xwindow
= XtWindow (widget
);
4588 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
4592 #endif /* not USE_GTK */
4595 /* Set the thumb size and position of scroll bar BAR. We are currently
4596 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4600 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4601 struct scroll_bar
*bar
;
4602 int portion
, position
, whole
;
4604 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4607 #else /* not USE_GTK */
4609 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4610 struct scroll_bar
*bar
;
4611 int portion
, position
, whole
;
4613 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4614 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4621 /* We use an estimate of 30 chars per line rather than the real
4622 `portion' value. This has the disadvantage that the thumb size
4623 is not very representative, but it makes our life a lot easier.
4624 Otherwise, we have to constantly adjust the thumb size, which
4625 we can't always do quickly enough: while dragging, the size of
4626 the thumb might prevent the user from dragging the thumb all the
4627 way to the end. but Motif and some versions of Xaw3d don't allow
4628 updating the thumb size while dragging. Also, even if we can update
4629 its size, the update will often happen too late.
4630 If you don't believe it, check out revision 1.650 of xterm.c to see
4631 what hoops we were going through and the still poor behavior we got. */
4632 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4633 /* When the thumb is at the bottom, position == whole.
4634 So we need to increase `whole' to make space for the thumb. */
4641 top
= (float) position
/ whole
;
4642 shown
= (float) portion
/ whole
;
4645 if (NILP (bar
->dragging
))
4649 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4650 is the scroll bar's maximum and MIN is the scroll bar's minimum
4652 size
= shown
* XM_SB_MAX
;
4653 size
= min (size
, XM_SB_MAX
);
4654 size
= max (size
, 1);
4656 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4657 value
= top
* XM_SB_MAX
;
4658 value
= min (value
, XM_SB_MAX
- size
);
4660 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4662 #else /* !USE_MOTIF i.e. use Xaw */
4668 top
= (float) position
/ whole
;
4669 shown
= (float) portion
/ whole
;
4673 float old_top
, old_shown
;
4675 XtVaGetValues (widget
,
4676 XtNtopOfThumb
, &old_top
,
4677 XtNshown
, &old_shown
,
4681 /* Massage the top+shown values. */
4682 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4683 top
= max (0, min (1, top
));
4686 /* Keep two pixels available for moving the thumb down. */
4687 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4689 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4690 check that your system's configuration file contains a define
4691 for `NARROWPROTO'. See s/freebsd.h for an example. */
4692 if (top
!= old_top
|| shown
!= old_shown
)
4694 if (NILP (bar
->dragging
))
4695 XawScrollbarSetThumb (widget
, top
, shown
);
4698 /* Try to make the scrolling a tad smoother. */
4699 if (!xaw3d_pick_top
)
4700 shown
= min (shown
, old_shown
);
4702 XawScrollbarSetThumb (widget
, top
, shown
);
4706 #endif /* !USE_MOTIF */
4710 #endif /* not USE_GTK */
4712 #endif /* USE_TOOLKIT_SCROLL_BARS */
4716 /************************************************************************
4717 Scroll bars, general
4718 ************************************************************************/
4720 /* Create a scroll bar and return the scroll bar vector for it. W is
4721 the Emacs window on which to create the scroll bar. TOP, LEFT,
4722 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4725 static struct scroll_bar
*
4726 x_scroll_bar_create (w
, top
, left
, width
, height
)
4728 int top
, left
, width
, height
;
4730 struct frame
*f
= XFRAME (w
->frame
);
4731 struct scroll_bar
*bar
4732 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
4736 #ifdef USE_TOOLKIT_SCROLL_BARS
4737 x_create_toolkit_scroll_bar (f
, bar
);
4738 #else /* not USE_TOOLKIT_SCROLL_BARS */
4740 XSetWindowAttributes a
;
4744 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4745 if (a
.background_pixel
== -1)
4746 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
4748 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4749 | ButtonMotionMask
| PointerMotionHintMask
4751 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4753 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4755 /* Clear the area of W that will serve as a scroll bar. This is
4756 for the case that a window has been split horizontally. In
4757 this case, no clear_frame is generated to reduce flickering. */
4758 if (width
> 0 && height
> 0)
4759 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4761 window_box_height (w
), False
);
4763 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4764 /* Position and size of scroll bar. */
4765 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4767 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4769 /* Border width, depth, class, and visual. */
4776 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
4778 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4780 XSETWINDOW (bar
->window
, w
);
4781 XSETINT (bar
->top
, top
);
4782 XSETINT (bar
->left
, left
);
4783 XSETINT (bar
->width
, width
);
4784 XSETINT (bar
->height
, height
);
4785 XSETINT (bar
->start
, 0);
4786 XSETINT (bar
->end
, 0);
4787 bar
->dragging
= Qnil
;
4789 /* Add bar to its frame's list of scroll bars. */
4790 bar
->next
= FRAME_SCROLL_BARS (f
);
4792 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4793 if (!NILP (bar
->next
))
4794 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4796 /* Map the window/widget. */
4797 #ifdef USE_TOOLKIT_SCROLL_BARS
4800 xg_update_scrollbar_pos (f
,
4801 SCROLL_BAR_X_WINDOW (bar
),
4803 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4804 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4806 xg_show_scroll_bar (SCROLL_BAR_X_WINDOW (bar
));
4807 #else /* not USE_GTK */
4808 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4809 XtConfigureWidget (scroll_bar
,
4810 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4812 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4813 max (height
, 1), 0);
4814 XtMapWidget (scroll_bar
);
4815 #endif /* not USE_GTK */
4817 #else /* not USE_TOOLKIT_SCROLL_BARS */
4818 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
4819 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4826 /* Draw BAR's handle in the proper position.
4828 If the handle is already drawn from START to END, don't bother
4829 redrawing it, unless REBUILD is non-zero; in that case, always
4830 redraw it. (REBUILD is handy for drawing the handle after expose
4833 Normally, we want to constrain the start and end of the handle to
4834 fit inside its rectangle, but if the user is dragging the scroll
4835 bar handle, we want to let them drag it down all the way, so that
4836 the bar's top is as far down as it goes; otherwise, there's no way
4837 to move to the very end of the buffer. */
4839 #ifndef USE_TOOLKIT_SCROLL_BARS
4842 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
4843 struct scroll_bar
*bar
;
4847 int dragging
= ! NILP (bar
->dragging
);
4848 Window w
= SCROLL_BAR_X_WINDOW (bar
);
4849 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4850 GC gc
= f
->output_data
.x
->normal_gc
;
4852 /* If the display is already accurate, do nothing. */
4854 && start
== XINT (bar
->start
)
4855 && end
== XINT (bar
->end
))
4861 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
4862 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
4863 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4865 /* Make sure the values are reasonable, and try to preserve
4866 the distance between start and end. */
4868 int length
= end
- start
;
4872 else if (start
> top_range
)
4874 end
= start
+ length
;
4878 else if (end
> top_range
&& ! dragging
)
4882 /* Store the adjusted setting in the scroll bar. */
4883 XSETINT (bar
->start
, start
);
4884 XSETINT (bar
->end
, end
);
4886 /* Clip the end position, just for display. */
4887 if (end
> top_range
)
4890 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4891 below top positions, to make sure the handle is always at least
4892 that many pixels tall. */
4893 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4895 /* Draw the empty space above the handle. Note that we can't clear
4896 zero-height areas; that means "clear to end of window." */
4898 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4899 /* x, y, width, height, and exposures. */
4900 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4901 VERTICAL_SCROLL_BAR_TOP_BORDER
,
4902 inside_width
, start
,
4905 /* Change to proper foreground color if one is specified. */
4906 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4907 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4908 f
->output_data
.x
->scroll_bar_foreground_pixel
);
4910 /* Draw the handle itself. */
4911 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
4912 /* x, y, width, height */
4913 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4914 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
4915 inside_width
, end
- start
);
4917 /* Restore the foreground color of the GC if we changed it above. */
4918 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4919 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4920 f
->output_data
.x
->foreground_pixel
);
4922 /* Draw the empty space below the handle. Note that we can't
4923 clear zero-height areas; that means "clear to end of window." */
4924 if (end
< inside_height
)
4925 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4926 /* x, y, width, height, and exposures. */
4927 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4928 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
4929 inside_width
, inside_height
- end
,
4937 #endif /* !USE_TOOLKIT_SCROLL_BARS */
4939 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4943 x_scroll_bar_remove (bar
)
4944 struct scroll_bar
*bar
;
4946 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4949 #ifdef USE_TOOLKIT_SCROLL_BARS
4951 xg_remove_scroll_bar (f
, SCROLL_BAR_X_WINDOW (bar
));
4952 #else /* not USE_GTK */
4953 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
4954 #endif /* not USE_GTK */
4956 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
4959 /* Disassociate this scroll bar from its window. */
4960 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
4966 /* Set the handle of the vertical scroll bar for WINDOW to indicate
4967 that we are displaying PORTION characters out of a total of WHOLE
4968 characters, starting at POSITION. If WINDOW has no scroll bar,
4972 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
4974 int portion
, whole
, position
;
4976 struct frame
*f
= XFRAME (w
->frame
);
4977 struct scroll_bar
*bar
;
4978 int top
, height
, left
, sb_left
, width
, sb_width
;
4979 int window_y
, window_height
;
4981 /* Get window dimensions. */
4982 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
4984 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
4985 height
= window_height
;
4987 /* Compute the left edge of the scroll bar area. */
4988 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
4990 /* Compute the width of the scroll bar which might be less than
4991 the width of the area reserved for the scroll bar. */
4992 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
4993 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
4997 /* Compute the left edge of the scroll bar. */
4998 #ifdef USE_TOOLKIT_SCROLL_BARS
4999 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5001 (WINDOW_RIGHTMOST_P (w
)
5002 ? width
- sb_width
- (width
- sb_width
) / 2
5006 (WINDOW_LEFTMOST_P (w
)
5007 ? (width
- sb_width
) / 2
5008 : width
- sb_width
));
5010 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5011 sb_left
= left
+ width
- sb_width
;
5016 /* Does the scroll bar exist yet? */
5017 if (NILP (w
->vertical_scroll_bar
))
5019 if (width
> 0 && height
> 0)
5022 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5023 left
, top
, width
, height
, False
);
5027 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5031 /* It may just need to be moved and resized. */
5032 unsigned int mask
= 0;
5034 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5038 if (sb_left
!= XINT (bar
->left
))
5040 if (top
!= XINT (bar
->top
))
5042 if (sb_width
!= XINT (bar
->width
))
5044 if (height
!= XINT (bar
->height
))
5047 #ifdef USE_TOOLKIT_SCROLL_BARS
5049 /* Move/size the scroll bar widget. */
5052 /* Since toolkit scroll bars are smaller than the space reserved
5053 for them on the frame, we have to clear "under" them. */
5054 if (width
> 0 && height
> 0)
5055 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5056 left
, top
, width
, height
, False
);
5058 xg_update_scrollbar_pos (f
,
5059 SCROLL_BAR_X_WINDOW (bar
),
5061 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5062 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5064 #else /* not USE_GTK */
5065 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5066 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5068 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5069 max (height
, 1), 0);
5070 #endif /* not USE_GTK */
5072 #else /* not USE_TOOLKIT_SCROLL_BARS */
5074 /* Clear areas not covered by the scroll bar because of
5075 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5076 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5078 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5079 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5081 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5082 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5083 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5087 /* Clear areas not covered by the scroll bar because it's not as
5088 wide as the area reserved for it. This makes sure a
5089 previous mode line display is cleared after C-x 2 C-x 1, for
5092 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5093 int rest
= area_width
- sb_width
;
5094 if (rest
> 0 && height
> 0)
5096 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5097 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5098 left
+ area_width
- rest
, top
,
5099 rest
, height
, False
);
5101 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5102 left
, top
, rest
, height
, False
);
5106 /* Move/size the scroll bar window. */
5111 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5113 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5115 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
5119 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5121 /* Remember new settings. */
5122 XSETINT (bar
->left
, sb_left
);
5123 XSETINT (bar
->top
, top
);
5124 XSETINT (bar
->width
, sb_width
);
5125 XSETINT (bar
->height
, height
);
5130 #ifdef USE_TOOLKIT_SCROLL_BARS
5131 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5132 #else /* not USE_TOOLKIT_SCROLL_BARS */
5133 /* Set the scroll bar's current state, unless we're currently being
5135 if (NILP (bar
->dragging
))
5137 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5140 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5143 int start
= ((double) position
* top_range
) / whole
;
5144 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5145 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5148 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5150 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5154 /* The following three hooks are used when we're doing a thorough
5155 redisplay of the frame. We don't explicitly know which scroll bars
5156 are going to be deleted, because keeping track of when windows go
5157 away is a real pain - "Can you say set-window-configuration, boys
5158 and girls?" Instead, we just assert at the beginning of redisplay
5159 that *all* scroll bars are to be removed, and then save a scroll bar
5160 from the fiery pit when we actually redisplay its window. */
5162 /* Arrange for all scroll bars on FRAME to be removed at the next call
5163 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5164 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5167 XTcondemn_scroll_bars (frame
)
5170 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5171 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5174 bar
= FRAME_SCROLL_BARS (frame
);
5175 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5176 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5177 XSCROLL_BAR (bar
)->prev
= Qnil
;
5178 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5179 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5180 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5185 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5186 Note that WINDOW isn't necessarily condemned at all. */
5189 XTredeem_scroll_bar (window
)
5190 struct window
*window
;
5192 struct scroll_bar
*bar
;
5195 /* We can't redeem this window's scroll bar if it doesn't have one. */
5196 if (NILP (window
->vertical_scroll_bar
))
5199 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5201 /* Unlink it from the condemned list. */
5202 f
= XFRAME (WINDOW_FRAME (window
));
5203 if (NILP (bar
->prev
))
5205 /* If the prev pointer is nil, it must be the first in one of
5207 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5208 /* It's not condemned. Everything's fine. */
5210 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5211 window
->vertical_scroll_bar
))
5212 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5214 /* If its prev pointer is nil, it must be at the front of
5215 one or the other! */
5219 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5221 if (! NILP (bar
->next
))
5222 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5224 bar
->next
= FRAME_SCROLL_BARS (f
);
5226 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5227 if (! NILP (bar
->next
))
5228 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5231 /* Remove all scroll bars on FRAME that haven't been saved since the
5232 last call to `*condemn_scroll_bars_hook'. */
5235 XTjudge_scroll_bars (f
)
5238 Lisp_Object bar
, next
;
5240 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5242 /* Clear out the condemned list now so we won't try to process any
5243 more events on the hapless scroll bars. */
5244 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5246 for (; ! NILP (bar
); bar
= next
)
5248 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5250 x_scroll_bar_remove (b
);
5253 b
->next
= b
->prev
= Qnil
;
5256 /* Now there should be no references to the condemned scroll bars,
5257 and they should get garbage-collected. */
5261 #ifndef USE_TOOLKIT_SCROLL_BARS
5262 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5263 is a no-op when using toolkit scroll bars.
5265 This may be called from a signal handler, so we have to ignore GC
5269 x_scroll_bar_expose (bar
, event
)
5270 struct scroll_bar
*bar
;
5273 Window w
= SCROLL_BAR_X_WINDOW (bar
);
5274 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5275 GC gc
= f
->output_data
.x
->normal_gc
;
5276 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5280 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
5282 /* Switch to scroll bar foreground color. */
5283 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5284 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5285 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5287 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5288 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5290 /* x, y, width, height */
5292 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
5293 XINT (bar
->height
) - 1);
5295 /* Restore the foreground color of the GC if we changed it above. */
5296 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5297 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5298 f
->output_data
.x
->foreground_pixel
);
5303 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5305 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5306 is set to something other than NO_EVENT, it is enqueued.
5308 This may be called from a signal handler, so we have to ignore GC
5313 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
5314 struct scroll_bar
*bar
;
5316 struct input_event
*emacs_event
;
5318 if (! GC_WINDOWP (bar
->window
))
5321 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5322 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5323 emacs_event
->modifiers
5324 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5325 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5326 event
->xbutton
.state
)
5327 | (event
->type
== ButtonRelease
5330 emacs_event
->frame_or_window
= bar
->window
;
5331 emacs_event
->arg
= Qnil
;
5332 emacs_event
->timestamp
= event
->xbutton
.time
;
5335 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5337 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
5340 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5341 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5344 if (y
> top_range
) y
= top_range
;
5346 if (y
< XINT (bar
->start
))
5347 emacs_event
->part
= scroll_bar_above_handle
;
5348 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5349 emacs_event
->part
= scroll_bar_handle
;
5351 emacs_event
->part
= scroll_bar_below_handle
;
5353 /* Just because the user has clicked on the handle doesn't mean
5354 they want to drag it. Lisp code needs to be able to decide
5355 whether or not we're dragging. */
5357 /* If the user has just clicked on the handle, record where they're
5359 if (event
->type
== ButtonPress
5360 && emacs_event
->part
== scroll_bar_handle
)
5361 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
5364 #ifndef USE_TOOLKIT_SCROLL_BARS
5365 /* If the user has released the handle, set it to its final position. */
5366 if (event
->type
== ButtonRelease
5367 && ! NILP (bar
->dragging
))
5369 int new_start
= y
- XINT (bar
->dragging
);
5370 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5372 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5373 bar
->dragging
= Qnil
;
5377 /* Same deal here as the other #if 0. */
5379 /* Clicks on the handle are always reported as occurring at the top of
5381 if (emacs_event
->part
== scroll_bar_handle
)
5382 emacs_event
->x
= bar
->start
;
5384 XSETINT (emacs_event
->x
, y
);
5386 XSETINT (emacs_event
->x
, y
);
5389 XSETINT (emacs_event
->y
, top_range
);
5393 #ifndef USE_TOOLKIT_SCROLL_BARS
5395 /* Handle some mouse motion while someone is dragging the scroll bar.
5397 This may be called from a signal handler, so we have to ignore GC
5401 x_scroll_bar_note_movement (bar
, event
)
5402 struct scroll_bar
*bar
;
5405 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5407 last_mouse_movement_time
= event
->xmotion
.time
;
5410 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5412 /* If we're dragging the bar, display it. */
5413 if (! GC_NILP (bar
->dragging
))
5415 /* Where should the handle be now? */
5416 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5418 if (new_start
!= XINT (bar
->start
))
5420 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5422 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5427 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5429 /* Return information to the user about the current position of the mouse
5430 on the scroll bar. */
5433 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
5435 Lisp_Object
*bar_window
;
5436 enum scroll_bar_part
*part
;
5438 unsigned long *time
;
5440 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5441 Window w
= SCROLL_BAR_X_WINDOW (bar
);
5442 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5444 Window dummy_window
;
5446 unsigned int dummy_mask
;
5450 /* Get the mouse's position relative to the scroll bar window, and
5452 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5454 /* Root, child, root x and root y. */
5455 &dummy_window
, &dummy_window
,
5456 &dummy_coord
, &dummy_coord
,
5458 /* Position relative to scroll bar. */
5461 /* Mouse buttons and modifier keys. */
5468 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
5471 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5473 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5475 if (! NILP (bar
->dragging
))
5476 win_y
-= XINT (bar
->dragging
);
5480 if (win_y
> top_range
)
5484 *bar_window
= bar
->window
;
5486 if (! NILP (bar
->dragging
))
5487 *part
= scroll_bar_handle
;
5488 else if (win_y
< XINT (bar
->start
))
5489 *part
= scroll_bar_above_handle
;
5490 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5491 *part
= scroll_bar_handle
;
5493 *part
= scroll_bar_below_handle
;
5495 XSETINT (*x
, win_y
);
5496 XSETINT (*y
, top_range
);
5499 last_mouse_scroll_bar
= Qnil
;
5502 *time
= last_mouse_movement_time
;
5508 /* The screen has been cleared so we may have changed foreground or
5509 background colors, and the scroll bars may need to be redrawn.
5510 Clear out the scroll bars, and ask for expose events, so we can
5514 x_scroll_bar_clear (f
)
5517 #ifndef USE_TOOLKIT_SCROLL_BARS
5520 /* We can have scroll bars even if this is 0,
5521 if we just turned off scroll bar mode.
5522 But in that case we should not clear them. */
5523 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5524 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5525 bar
= XSCROLL_BAR (bar
)->next
)
5526 XClearArea (FRAME_X_DISPLAY (f
),
5527 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
5529 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5533 /* The main X event-reading loop - XTread_socket. */
5536 /* Time stamp of enter window event. This is only used by XTread_socket,
5537 but we have to put it out here, since static variables within functions
5538 sometimes don't work. */
5540 static Time enter_timestamp
;
5543 /* This holds the state XLookupString needs to implement dead keys
5544 and other tricks known as "compose processing". _X Window System_
5545 says that a portable program can't use this, but Stephen Gildea assures
5546 me that letting the compiler initialize it to zeros will work okay.
5548 This must be defined outside of XTread_socket, for the same reasons
5549 given for enter_timestamp, above. */
5551 static XComposeStatus compose_status
;
5553 /* Record the last 100 characters stored
5554 to help debug the loss-of-chars-during-GC problem. */
5556 static int temp_index
;
5557 static short temp_buffer
[100];
5559 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5560 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5562 temp_buffer[temp_index++] = (keysym)
5564 /* Set this to nonzero to fake an "X I/O error"
5565 on a particular display. */
5567 struct x_display_info
*XTread_socket_fake_io_error
;
5569 /* When we find no input here, we occasionally do a no-op command
5570 to verify that the X server is still running and we can still talk with it.
5571 We try all the open displays, one by one.
5572 This variable is used for cycling thru the displays. */
5574 static struct x_display_info
*next_noop_dpyinfo
;
5576 #define SET_SAVED_MENU_EVENT(size) \
5579 if (f->output_data.x->saved_menu_event == 0) \
5580 f->output_data.x->saved_menu_event \
5581 = (XEvent *) xmalloc (sizeof (XEvent)); \
5582 bcopy (&event, f->output_data.x->saved_menu_event, size); \
5583 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5584 XSETFRAME (inev.ie.frame_or_window, f); \
5588 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
5589 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
5599 /* Filter events for the current X input method.
5600 DPYINFO is the display this event is for.
5601 EVENT is the X event to filter.
5603 Returns non-zero if the event was filtered, caller shall not process
5605 Returns zero if event is wasn't filtered. */
5609 x_filter_event (dpyinfo
, event
)
5610 struct x_display_info
*dpyinfo
;
5613 /* XFilterEvent returns non-zero if the input method has
5614 consumed the event. We pass the frame's X window to
5615 XFilterEvent because that's the one for which the IC
5618 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5619 event
->xclient
.window
);
5621 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5626 static int current_count
;
5627 static int current_finish
;
5628 static struct input_event
*current_hold_quit
;
5630 /* This is the filter function invoked by the GTK event loop.
5631 It is invoked before the XEvent is translated to a GdkEvent,
5632 so we have a chance to act on the event before GTK. */
5633 static GdkFilterReturn
5634 event_handler_gdk (gxev
, ev
, data
)
5639 XEvent
*xev
= (XEvent
*) gxev
;
5641 if (current_count
>= 0)
5643 struct x_display_info
*dpyinfo
;
5645 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5648 /* Filter events for the current X input method.
5649 GTK calls XFilterEvent but not for key press and release,
5650 so we do it here. */
5651 if (xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5652 if (dpyinfo
&& x_filter_event (dpyinfo
, xev
))
5653 return GDK_FILTER_REMOVE
;
5657 current_finish
= X_EVENT_NORMAL
;
5661 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5666 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5668 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5669 return GDK_FILTER_REMOVE
;
5671 return GDK_FILTER_CONTINUE
;
5673 #endif /* USE_GTK */
5676 /* Handles the XEvent EVENT on display DPYINFO.
5678 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5679 *FINISH is zero if caller should continue reading events.
5680 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5682 We return the number of characters stored into the buffer. */
5685 handle_one_xevent (dpyinfo
, eventp
, finish
, hold_quit
)
5686 struct x_display_info
*dpyinfo
;
5689 struct input_event
*hold_quit
;
5692 struct input_event ie
;
5693 struct selection_input_event sie
;
5699 struct coding_system coding
;
5700 XEvent event
= *eventp
;
5702 *finish
= X_EVENT_NORMAL
;
5704 EVENT_INIT (inev
.ie
);
5705 inev
.ie
.kind
= NO_EVENT
;
5712 if (event
.xclient
.message_type
5713 == dpyinfo
->Xatom_wm_protocols
5714 && event
.xclient
.format
== 32)
5716 if (event
.xclient
.data
.l
[0]
5717 == dpyinfo
->Xatom_wm_take_focus
)
5719 /* Use x_any_window_to_frame because this
5720 could be the shell widget window
5721 if the frame has no title bar. */
5722 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5724 /* Not quite sure this is needed -pd */
5725 if (f
&& FRAME_XIC (f
))
5726 XSetICFocus (FRAME_XIC (f
));
5728 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5729 instructs the WM to set the input focus automatically for
5730 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5731 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5732 it has set the focus. So, XSetInputFocus below is not
5735 The call to XSetInputFocus below has also caused trouble. In
5736 cases where the XSetInputFocus done by the WM and the one
5737 below are temporally close (on a fast machine), the call
5738 below can generate additional FocusIn events which confuse
5741 /* Since we set WM_TAKE_FOCUS, we must call
5742 XSetInputFocus explicitly. But not if f is null,
5743 since that might be an event for a deleted frame. */
5746 Display
*d
= event
.xclient
.display
;
5747 /* Catch and ignore errors, in case window has been
5748 iconified by a window manager such as GWM. */
5750 XSetInputFocus (d
, event
.xclient
.window
,
5751 /* The ICCCM says this is
5752 the only valid choice. */
5754 event
.xclient
.data
.l
[1]);
5755 /* This is needed to detect the error
5756 if there is an error. */
5758 x_uncatch_errors ();
5760 /* Not certain about handling scroll bars here */
5765 if (event
.xclient
.data
.l
[0]
5766 == dpyinfo
->Xatom_wm_save_yourself
)
5768 /* Save state modify the WM_COMMAND property to
5769 something which can reinstate us. This notifies
5770 the session manager, who's looking for such a
5771 PropertyNotify. Can restart processing when
5772 a keyboard or mouse event arrives. */
5773 /* If we have a session manager, don't set this.
5774 KDE will then start two Emacsen, one for the
5775 session manager and one for this. */
5777 if (! x_session_have_connection ())
5780 f
= x_top_window_to_frame (dpyinfo
,
5781 event
.xclient
.window
);
5782 /* This is just so we only give real data once
5783 for a single Emacs process. */
5784 if (f
== SELECTED_FRAME ())
5785 XSetCommand (FRAME_X_DISPLAY (f
),
5786 event
.xclient
.window
,
5787 initial_argv
, initial_argc
);
5789 XSetCommand (FRAME_X_DISPLAY (f
),
5790 event
.xclient
.window
,
5796 if (event
.xclient
.data
.l
[0]
5797 == dpyinfo
->Xatom_wm_delete_window
)
5799 f
= x_any_window_to_frame (dpyinfo
,
5800 event
.xclient
.window
);
5802 goto OTHER
; /* May be a dialog that is to be removed */
5804 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5805 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5812 if (event
.xclient
.message_type
5813 == dpyinfo
->Xatom_wm_configure_denied
)
5818 if (event
.xclient
.message_type
5819 == dpyinfo
->Xatom_wm_window_moved
)
5822 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5824 new_x
= event
.xclient
.data
.s
[0];
5825 new_y
= event
.xclient
.data
.s
[1];
5829 f
->left_pos
= new_x
;
5836 if (event
.xclient
.message_type
5837 == dpyinfo
->Xatom_editres
)
5839 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5841 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5845 #endif /* HACK_EDITRES */
5847 if ((event
.xclient
.message_type
5848 == dpyinfo
->Xatom_DONE
)
5849 || (event
.xclient
.message_type
5850 == dpyinfo
->Xatom_PAGE
))
5852 /* Ghostview job completed. Kill it. We could
5853 reply with "Next" if we received "Page", but we
5854 currently never do because we are interested in
5855 images, only, which should have 1 page. */
5856 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5857 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5860 x_kill_gs_process (pixmap
, f
);
5861 expose_frame (f
, 0, 0, 0, 0);
5865 #ifdef USE_TOOLKIT_SCROLL_BARS
5866 /* Scroll bar callbacks send a ClientMessage from which
5867 we construct an input_event. */
5868 if (event
.xclient
.message_type
5869 == dpyinfo
->Xatom_Scrollbar
)
5871 x_scroll_bar_to_input_event (&event
, &inev
.ie
);
5872 *finish
= X_EVENT_GOTO_OUT
;
5875 #endif /* USE_TOOLKIT_SCROLL_BARS */
5877 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5880 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
.ie
))
5881 *finish
= X_EVENT_DROP
;
5885 case SelectionNotify
:
5886 last_user_time
= event
.xselection
.time
;
5887 #ifdef USE_X_TOOLKIT
5888 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
5890 #endif /* not USE_X_TOOLKIT */
5891 x_handle_selection_notify (&event
.xselection
);
5894 case SelectionClear
: /* Someone has grabbed ownership. */
5895 last_user_time
= event
.xselectionclear
.time
;
5896 #ifdef USE_X_TOOLKIT
5897 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
5899 #endif /* USE_X_TOOLKIT */
5901 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
5903 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5904 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5905 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5906 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5907 inev
.ie
.frame_or_window
= Qnil
;
5911 case SelectionRequest
: /* Someone wants our selection. */
5912 last_user_time
= event
.xselectionrequest
.time
;
5913 #ifdef USE_X_TOOLKIT
5914 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
5916 #endif /* USE_X_TOOLKIT */
5918 XSelectionRequestEvent
*eventp
5919 = (XSelectionRequestEvent
*) &event
;
5921 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
5922 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5923 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
5924 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5925 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
5926 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
5927 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5928 inev
.ie
.frame_or_window
= Qnil
;
5932 case PropertyNotify
:
5933 last_user_time
= event
.xproperty
.time
;
5934 #if 0 /* This is plain wrong. In the case that we are waiting for a
5935 PropertyNotify used as an ACK in incremental selection
5936 transfer, the property will be on the receiver's window. */
5937 #if defined USE_X_TOOLKIT
5938 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
5942 x_handle_property_notify (&event
.xproperty
);
5945 case ReparentNotify
:
5946 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
5950 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
5951 x_real_positions (f
, &x
, &y
);
5955 /* Perhaps reparented due to a WM restart. Reset this. */
5956 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
5957 FRAME_X_DISPLAY_INFO (f
)->net_supported_window
= 0;
5962 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
5965 x_check_fullscreen (f
);
5968 /* This seems to be needed for GTK 2.6. */
5969 x_clear_area (event
.xexpose
.display
,
5970 event
.xexpose
.window
,
5971 event
.xexpose
.x
, event
.xexpose
.y
,
5972 event
.xexpose
.width
, event
.xexpose
.height
,
5975 if (f
->async_visible
== 0)
5977 f
->async_visible
= 1;
5978 f
->async_iconified
= 0;
5979 f
->output_data
.x
->has_been_visible
= 1;
5980 SET_FRAME_GARBAGED (f
);
5984 event
.xexpose
.x
, event
.xexpose
.y
,
5985 event
.xexpose
.width
, event
.xexpose
.height
);
5989 #ifndef USE_TOOLKIT_SCROLL_BARS
5990 struct scroll_bar
*bar
;
5992 #if defined USE_LUCID
5993 /* Submenus of the Lucid menu bar aren't widgets
5994 themselves, so there's no way to dispatch events
5995 to them. Recognize this case separately. */
5998 = x_window_to_menu_bar (event
.xexpose
.window
);
6000 xlwmenu_redisplay (widget
);
6002 #endif /* USE_LUCID */
6004 #ifdef USE_TOOLKIT_SCROLL_BARS
6005 /* Dispatch event to the widget. */
6007 #else /* not USE_TOOLKIT_SCROLL_BARS */
6008 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
6009 event
.xexpose
.window
);
6012 x_scroll_bar_expose (bar
, &event
);
6013 #ifdef USE_X_TOOLKIT
6016 #endif /* USE_X_TOOLKIT */
6017 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6021 case GraphicsExpose
: /* This occurs when an XCopyArea's
6022 source area was obscured or not
6024 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6028 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6029 event
.xgraphicsexpose
.width
,
6030 event
.xgraphicsexpose
.height
);
6032 #ifdef USE_X_TOOLKIT
6035 #endif /* USE_X_TOOLKIT */
6038 case NoExpose
: /* This occurs when an XCopyArea's
6039 source area was completely
6044 /* Redo the mouse-highlight after the tooltip has gone. */
6045 if (event
.xmap
.window
== tip_window
)
6048 redo_mouse_highlight ();
6051 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6052 if (f
) /* F may no longer exist if
6053 the frame was deleted. */
6055 /* While a frame is unmapped, display generation is
6056 disabled; you don't want to spend time updating a
6057 display that won't ever be seen. */
6058 f
->async_visible
= 0;
6059 /* We can't distinguish, from the event, whether the window
6060 has become iconified or invisible. So assume, if it
6061 was previously visible, than now it is iconified.
6062 But x_make_frame_invisible clears both
6063 the visible flag and the iconified flag;
6064 and that way, we know the window is not iconified now. */
6065 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6067 f
->async_iconified
= 1;
6069 inev
.ie
.kind
= ICONIFY_EVENT
;
6070 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6076 if (event
.xmap
.window
== tip_window
)
6077 /* The tooltip has been drawn already. Avoid
6078 the SET_FRAME_GARBAGED below. */
6081 /* We use x_top_window_to_frame because map events can
6082 come for sub-windows and they don't mean that the
6083 frame is visible. */
6084 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6087 /* wait_reading_process_output will notice this and update
6088 the frame's display structures.
6089 If we where iconified, we should not set garbaged,
6090 because that stops redrawing on Expose events. This looks
6091 bad if we are called from a recursive event loop
6092 (x_dispatch_event), for example when a dialog is up. */
6093 if (! f
->async_iconified
)
6094 SET_FRAME_GARBAGED (f
);
6096 f
->async_visible
= 1;
6097 f
->async_iconified
= 0;
6098 f
->output_data
.x
->has_been_visible
= 1;
6102 inev
.ie
.kind
= DEICONIFY_EVENT
;
6103 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6105 else if (! NILP (Vframe_list
)
6106 && ! NILP (XCDR (Vframe_list
)))
6107 /* Force a redisplay sooner or later
6108 to update the frame titles
6109 in case this is the second frame. */
6110 record_asynch_buffer_change ();
6116 last_user_time
= event
.xkey
.time
;
6117 ignore_next_mouse_click_timeout
= 0;
6119 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6120 /* Dispatch KeyPress events when in menu. */
6121 if (popup_activated ())
6125 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6127 /* If mouse-highlight is an integer, input clears out
6128 mouse highlighting. */
6129 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6131 || !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)))
6133 clear_mouse_face (dpyinfo
);
6134 dpyinfo
->mouse_face_hidden
= 1;
6137 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6140 /* Scroll bars consume key events, but we want
6141 the keys to go to the scroll bar's frame. */
6142 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6144 if (widget
&& XmIsScrollBar (widget
))
6146 widget
= XtParent (widget
);
6147 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6150 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6154 KeySym keysym
, orig_keysym
;
6155 /* al%imercury@uunet.uu.net says that making this 81
6156 instead of 80 fixed a bug whereby meta chars made
6159 It seems that some version of XmbLookupString has
6160 a bug of not returning XBufferOverflow in
6161 status_return even if the input is too long to
6162 fit in 81 bytes. So, we must prepare sufficient
6163 bytes for copy_buffer. 513 bytes (256 chars for
6164 two-byte character set) seems to be a fairly good
6165 approximation. -- 2000.8.10 handa@etl.go.jp */
6166 unsigned char copy_buffer
[513];
6167 unsigned char *copy_bufptr
= copy_buffer
;
6168 int copy_bufsiz
= sizeof (copy_buffer
);
6170 Lisp_Object coding_system
= Qlatin_1
;
6174 /* Don't pass keys to GTK. A Tab will shift focus to the
6175 tool bar in GTK 2.4. Keys will still go to menus and
6176 dialogs because in that case popup_activated is TRUE
6178 *finish
= X_EVENT_DROP
;
6182 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6183 extra_keyboard_modifiers
);
6184 modifiers
= event
.xkey
.state
;
6186 /* This will have to go some day... */
6188 /* make_lispy_event turns chars into control chars.
6189 Don't do it here because XLookupString is too eager. */
6190 event
.xkey
.state
&= ~ControlMask
;
6191 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6192 | dpyinfo
->super_mod_mask
6193 | dpyinfo
->hyper_mod_mask
6194 | dpyinfo
->alt_mod_mask
);
6196 /* In case Meta is ComposeCharacter,
6197 clear its status. According to Markus Ehrnsperger
6198 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6199 this enables ComposeCharacter to work whether or
6200 not it is combined with Meta. */
6201 if (modifiers
& dpyinfo
->meta_mod_mask
)
6202 bzero (&compose_status
, sizeof (compose_status
));
6207 Status status_return
;
6209 coding_system
= Vlocale_coding_system
;
6210 nbytes
= XmbLookupString (FRAME_XIC (f
),
6211 &event
.xkey
, copy_bufptr
,
6212 copy_bufsiz
, &keysym
,
6214 if (status_return
== XBufferOverflow
)
6216 copy_bufsiz
= nbytes
+ 1;
6217 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6218 nbytes
= XmbLookupString (FRAME_XIC (f
),
6219 &event
.xkey
, copy_bufptr
,
6220 copy_bufsiz
, &keysym
,
6223 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6224 #if 0 && defined X_HAVE_UTF8_STRING
6225 else if (status_return
== XLookupKeySym
)
6226 { /* Try again but with utf-8. */
6227 coding_system
= Qutf_8
;
6228 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6229 &event
.xkey
, copy_bufptr
,
6230 copy_bufsiz
, &keysym
,
6232 if (status_return
== XBufferOverflow
)
6234 copy_bufsiz
= nbytes
+ 1;
6235 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6236 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6239 copy_bufsiz
, &keysym
,
6245 if (status_return
== XLookupNone
)
6247 else if (status_return
== XLookupChars
)
6252 else if (status_return
!= XLookupKeySym
6253 && status_return
!= XLookupBoth
)
6257 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6258 copy_bufsiz
, &keysym
,
6261 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6262 copy_bufsiz
, &keysym
,
6266 /* If not using XIM/XIC, and a compose sequence is in progress,
6267 we break here. Otherwise, chars_matched is always 0. */
6268 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6271 bzero (&compose_status
, sizeof (compose_status
));
6272 orig_keysym
= keysym
;
6274 /* Common for all keysym input events. */
6275 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6277 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6278 inev
.ie
.timestamp
= event
.xkey
.time
;
6280 /* First deal with keysyms which have defined
6281 translations to characters. */
6282 if (keysym
>= 32 && keysym
< 128)
6283 /* Avoid explicitly decoding each ASCII character. */
6285 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6286 inev
.ie
.code
= keysym
;
6290 /* Keysyms directly mapped to supported Unicode characters. */
6291 if ((keysym
>= 0x01000000 && keysym
<= 0x010033ff)
6292 || (keysym
>= 0x0100e000 && keysym
<= 0x0100ffff))
6294 int code
= keysym
& 0xFFFF, charset_id
, c1
, c2
;
6298 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6299 inev
.ie
.code
= code
;
6301 else if (code
< 0x100)
6304 charset_id
= CHARSET_8_BIT_CONTROL
;
6306 charset_id
= charset_latin_iso8859_1
;
6307 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6308 inev
.ie
.code
= MAKE_CHAR (charset_id
, code
, 0);
6313 charset_id
= charset_mule_unicode_0100_24ff
,
6315 else if (code
< 0xE000)
6316 charset_id
= charset_mule_unicode_2500_33ff
,
6319 charset_id
= charset_mule_unicode_e000_ffff
,
6321 c1
= (code
/ 96) + 32, c2
= (code
% 96) + 32;
6322 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6323 inev
.ie
.code
= MAKE_CHAR (charset_id
, c1
, c2
);
6328 /* Now non-ASCII. */
6329 if (HASH_TABLE_P (Vx_keysym_table
)
6330 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6334 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6335 ? ASCII_KEYSTROKE_EVENT
6336 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6337 inev
.ie
.code
= XFASTINT (c
);
6341 /* Random non-modifier sorts of keysyms. */
6342 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6343 || keysym
== XK_Delete
6344 #ifdef XK_ISO_Left_Tab
6345 || (keysym
>= XK_ISO_Left_Tab
6346 && keysym
<= XK_ISO_Enter
)
6348 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6349 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6351 /* This recognizes the "extended function
6352 keys". It seems there's no cleaner way.
6353 Test IsModifierKey to avoid handling
6354 mode_switch incorrectly. */
6355 || ((unsigned) (keysym
) >= XK_Select
6356 && (unsigned)(keysym
) < XK_KP_Space
)
6358 #ifdef XK_dead_circumflex
6359 || orig_keysym
== XK_dead_circumflex
6361 #ifdef XK_dead_grave
6362 || orig_keysym
== XK_dead_grave
6364 #ifdef XK_dead_tilde
6365 || orig_keysym
== XK_dead_tilde
6367 #ifdef XK_dead_diaeresis
6368 || orig_keysym
== XK_dead_diaeresis
6370 #ifdef XK_dead_macron
6371 || orig_keysym
== XK_dead_macron
6373 #ifdef XK_dead_degree
6374 || orig_keysym
== XK_dead_degree
6376 #ifdef XK_dead_acute
6377 || orig_keysym
== XK_dead_acute
6379 #ifdef XK_dead_cedilla
6380 || orig_keysym
== XK_dead_cedilla
6382 #ifdef XK_dead_breve
6383 || orig_keysym
== XK_dead_breve
6385 #ifdef XK_dead_ogonek
6386 || orig_keysym
== XK_dead_ogonek
6388 #ifdef XK_dead_caron
6389 || orig_keysym
== XK_dead_caron
6391 #ifdef XK_dead_doubleacute
6392 || orig_keysym
== XK_dead_doubleacute
6394 #ifdef XK_dead_abovedot
6395 || orig_keysym
== XK_dead_abovedot
6397 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6398 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6399 /* Any "vendor-specific" key is ok. */
6400 || (orig_keysym
& (1 << 28))
6401 || (keysym
!= NoSymbol
&& nbytes
== 0))
6402 && ! (IsModifierKey (orig_keysym
)
6404 #ifdef XK_Mode_switch
6405 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
6408 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
6410 #endif /* not HAVE_X11R5 */
6411 /* The symbols from XK_ISO_Lock
6412 to XK_ISO_Last_Group_Lock
6413 don't have real modifiers but
6414 should be treated similarly to
6415 Mode_switch by Emacs. */
6416 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6417 || ((unsigned)(orig_keysym
)
6419 && (unsigned)(orig_keysym
)
6420 <= XK_ISO_Last_Group_Lock
)
6424 STORE_KEYSYM_FOR_DEBUG (keysym
);
6425 /* make_lispy_event will convert this to a symbolic
6427 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6428 inev
.ie
.code
= keysym
;
6432 { /* Raw bytes, not keysym. */
6437 /* The input should be decoded with `coding_system'
6438 which depends on which X*LookupString function
6439 we used just above and the locale. */
6440 setup_coding_system (coding_system
, &coding
);
6441 coding
.src_multibyte
= 0;
6442 coding
.dst_multibyte
= 1;
6443 /* The input is converted to events, thus we can't
6444 handle composition. Anyway, there's no XIM that
6445 gives us composition information. */
6446 coding
.composing
= COMPOSITION_DISABLED
;
6448 for (i
= 0; i
< nbytes
; i
++)
6450 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6454 /* Decode the input data. */
6458 require
= decoding_buffer_size (&coding
, nbytes
);
6459 p
= (unsigned char *) alloca (require
);
6460 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6461 /* We explicitly disable composition handling because
6462 key data should not contain any composition sequence. */
6463 coding
.composing
= COMPOSITION_DISABLED
;
6464 decode_coding (&coding
, copy_bufptr
, p
, nbytes
, require
);
6465 nbytes
= coding
.produced
;
6466 nchars
= coding
.produced_char
;
6470 /* Convert the input data to a sequence of
6471 character events. */
6472 for (i
= 0; i
< nbytes
; i
+= len
)
6474 if (nchars
== nbytes
)
6475 c
= copy_bufptr
[i
], len
= 1;
6477 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
6479 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6480 ? ASCII_KEYSTROKE_EVENT
6481 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6483 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6486 /* Previous code updated count by nchars rather than nbytes,
6487 but that seems bogus to me. ++kfs */
6490 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6492 if (keysym
== NoSymbol
)
6498 /* Don't dispatch this event since XtDispatchEvent calls
6499 XFilterEvent, and two calls in a row may freeze the
6507 last_user_time
= event
.xkey
.time
;
6509 /* Don't dispatch this event since XtDispatchEvent calls
6510 XFilterEvent, and two calls in a row may freeze the
6518 last_user_time
= event
.xcrossing
.time
;
6519 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6521 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6523 if (f
&& x_mouse_click_focus_ignore_position
)
6524 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6527 if (event
.xcrossing
.focus
)
6529 /* Avoid nasty pop/raise loops. */
6530 if (f
&& (!(f
->auto_raise
)
6532 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
6534 x_new_focus_frame (dpyinfo
, f
);
6535 enter_timestamp
= event
.xcrossing
.time
;
6538 else if (f
== dpyinfo
->x_focus_frame
)
6539 x_new_focus_frame (dpyinfo
, 0);
6542 /* EnterNotify counts as mouse movement,
6543 so update things that depend on mouse position. */
6544 if (f
&& !f
->output_data
.x
->hourglass_p
)
6545 note_mouse_movement (f
, &event
.xmotion
);
6547 /* We may get an EnterNotify on the buttons in the toolbar. In that
6548 case we moved out of any highlighted area and need to note this. */
6549 if (!f
&& last_mouse_glyph_frame
)
6550 note_mouse_movement (last_mouse_glyph_frame
, &event
);
6555 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6559 last_user_time
= event
.xcrossing
.time
;
6560 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6562 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6565 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6567 /* If we move outside the frame, then we're
6568 certainly no longer on any text in the frame. */
6569 clear_mouse_face (dpyinfo
);
6570 dpyinfo
->mouse_face_mouse_frame
= 0;
6573 /* Generate a nil HELP_EVENT to cancel a help-echo.
6574 Do it only if there's something to cancel.
6575 Otherwise, the startup message is cleared when
6576 the mouse leaves the frame. */
6577 if (any_help_event_p
)
6581 /* See comment in EnterNotify above */
6582 else if (last_mouse_glyph_frame
)
6583 note_mouse_movement (last_mouse_glyph_frame
, &event
);
6588 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6593 last_user_time
= event
.xmotion
.time
;
6594 previous_help_echo_string
= help_echo_string
;
6595 help_echo_string
= Qnil
;
6597 if (dpyinfo
->grabbed
&& last_mouse_frame
6598 && FRAME_LIVE_P (last_mouse_frame
))
6599 f
= last_mouse_frame
;
6601 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6603 if (dpyinfo
->mouse_face_hidden
)
6605 dpyinfo
->mouse_face_hidden
= 0;
6606 clear_mouse_face (dpyinfo
);
6612 /* Generate SELECT_WINDOW_EVENTs when needed. */
6613 if (!NILP (Vmouse_autoselect_window
))
6617 window
= window_from_coordinates (f
,
6618 event
.xmotion
.x
, event
.xmotion
.y
,
6621 /* Window will be selected only when it is not selected now and
6622 last mouse movement event was not in it. Minibuffer window
6623 will be selected iff it is active. */
6624 if (WINDOWP (window
)
6625 && !EQ (window
, last_window
)
6626 && !EQ (window
, selected_window
))
6628 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6629 inev
.ie
.frame_or_window
= window
;
6634 if (!note_mouse_movement (f
, &event
.xmotion
))
6635 help_echo_string
= previous_help_echo_string
;
6639 #ifndef USE_TOOLKIT_SCROLL_BARS
6640 struct scroll_bar
*bar
6641 = x_window_to_scroll_bar (event
.xmotion
.display
,
6642 event
.xmotion
.window
);
6645 x_scroll_bar_note_movement (bar
, &event
);
6646 #endif /* USE_TOOLKIT_SCROLL_BARS */
6648 /* If we move outside the frame, then we're
6649 certainly no longer on any text in the frame. */
6650 clear_mouse_face (dpyinfo
);
6653 /* If the contents of the global variable help_echo_string
6654 has changed, generate a HELP_EVENT. */
6655 if (!NILP (help_echo_string
)
6656 || !NILP (previous_help_echo_string
))
6661 case ConfigureNotify
:
6662 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6665 #ifndef USE_X_TOOLKIT
6667 xg_resize_widgets (f
, event
.xconfigure
.width
,
6668 event
.xconfigure
.height
);
6669 #else /* not USE_GTK */
6670 /* If there is a pending resize for fullscreen, don't
6671 do this one, the right one will come later.
6672 The toolkit version doesn't seem to need this, but we
6673 need to reset it below. */
6675 = ((f
->want_fullscreen
& FULLSCREEN_WAIT
)
6676 && f
->new_text_cols
!= 0);
6677 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6678 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6683 /* In the toolkit version, change_frame_size
6684 is called by the code that handles resizing
6685 of the EmacsFrame widget. */
6687 /* Even if the number of character rows and columns has
6688 not changed, the font size may have changed, so we need
6689 to check the pixel dimensions as well. */
6690 if (columns
!= FRAME_COLS (f
)
6691 || rows
!= FRAME_LINES (f
)
6692 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6693 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6695 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6696 SET_FRAME_GARBAGED (f
);
6697 cancel_mouse_face (f
);
6699 #endif /* not USE_GTK */
6702 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6703 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6706 /* GTK creates windows but doesn't map them.
6707 Only get real positions and check fullscreen when mapped. */
6708 if (FRAME_GTK_OUTER_WIDGET (f
)
6709 && GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
6712 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6714 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
6715 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
6719 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6720 xic_set_statusarea (f
);
6723 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
6725 /* Since the WM decorations come below top_pos now,
6726 we must put them below top_pos in the future. */
6727 f
->win_gravity
= NorthWestGravity
;
6728 x_wm_set_size_hint (f
, (long) 0, 0);
6736 /* If we decide we want to generate an event to be seen
6737 by the rest of Emacs, we put it here. */
6740 bzero (&compose_status
, sizeof (compose_status
));
6741 last_mouse_glyph_frame
= 0;
6742 last_user_time
= event
.xbutton
.time
;
6744 if (dpyinfo
->grabbed
6746 && FRAME_LIVE_P (last_mouse_frame
))
6747 f
= last_mouse_frame
;
6749 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6753 /* Is this in the tool-bar? */
6754 if (WINDOWP (f
->tool_bar_window
)
6755 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6758 int x
= event
.xbutton
.x
;
6759 int y
= event
.xbutton
.y
;
6761 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
6762 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
6764 if (tool_bar_p
&& event
.xbutton
.button
< 4)
6766 if (event
.xbutton
.type
== ButtonPress
)
6767 handle_tool_bar_click (f
, x
, y
, 1, 0);
6769 handle_tool_bar_click (f
, x
, y
, 0,
6770 x_x_to_emacs_modifiers (dpyinfo
,
6771 event
.xbutton
.state
));
6776 if (!dpyinfo
->x_focus_frame
6777 || f
== dpyinfo
->x_focus_frame
)
6779 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6780 if (! popup_activated ())
6783 if (ignore_next_mouse_click_timeout
)
6785 if (event
.type
== ButtonPress
6786 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6788 ignore_next_mouse_click_timeout
= 0;
6789 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6791 if (event
.type
== ButtonRelease
)
6792 ignore_next_mouse_click_timeout
= 0;
6795 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6801 struct scroll_bar
*bar
6802 = x_window_to_scroll_bar (event
.xbutton
.display
,
6803 event
.xbutton
.window
);
6805 #ifdef USE_TOOLKIT_SCROLL_BARS
6806 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6808 if (bar
&& event
.xbutton
.state
& ControlMask
)
6810 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6811 *finish
= X_EVENT_DROP
;
6813 #else /* not USE_TOOLKIT_SCROLL_BARS */
6815 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6816 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6819 if (event
.type
== ButtonPress
)
6821 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6822 last_mouse_frame
= f
;
6825 last_tool_bar_item
= -1;
6828 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6830 /* Ignore any mouse motion that happened before this event;
6831 any subsequent mouse-movement Emacs events should reflect
6832 only motion after the ButtonPress/Release. */
6836 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6837 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6838 /* For a down-event in the menu bar,
6839 don't pass it to Xt right now.
6840 Instead, save it away
6841 and we will pass it to Xt from kbd_buffer_get_event.
6842 That way, we can run some Lisp code first. */
6845 ! popup_activated ()
6848 f
&& event
.type
== ButtonPress
6849 /* Verify the event is really within the menu bar
6850 and not just sent to it due to grabbing. */
6851 && event
.xbutton
.x
>= 0
6852 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6853 && event
.xbutton
.y
>= 0
6854 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6855 && event
.xbutton
.same_screen
)
6857 SET_SAVED_BUTTON_EVENT
;
6858 XSETFRAME (last_mouse_press_frame
, f
);
6860 *finish
= X_EVENT_DROP
;
6863 else if (event
.type
== ButtonPress
)
6865 last_mouse_press_frame
= Qnil
;
6869 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6870 but I am trying to be cautious. */
6871 else if (event
.type
== ButtonRelease
)
6873 if (!NILP (last_mouse_press_frame
))
6875 f
= XFRAME (last_mouse_press_frame
);
6876 if (f
->output_data
.x
)
6877 SET_SAVED_BUTTON_EVENT
;
6882 #endif /* USE_MOTIF */
6885 #endif /* USE_X_TOOLKIT || USE_GTK */
6889 case CirculateNotify
:
6892 case CirculateRequest
:
6895 case VisibilityNotify
:
6899 /* Someone has changed the keyboard mapping - update the
6901 switch (event
.xmapping
.request
)
6903 case MappingModifier
:
6904 x_find_modifier_meanings (dpyinfo
);
6905 /* This is meant to fall through. */
6906 case MappingKeyboard
:
6907 XRefreshKeyboardMapping (&event
.xmapping
);
6913 #ifdef USE_X_TOOLKIT
6915 if (*finish
!= X_EVENT_DROP
)
6916 XtDispatchEvent (&event
);
6918 #endif /* USE_X_TOOLKIT */
6923 if (inev
.ie
.kind
!= NO_EVENT
)
6925 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6930 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6935 XSETFRAME (frame
, f
);
6941 any_help_event_p
= 1;
6942 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6943 help_echo_object
, help_echo_pos
);
6947 help_echo_string
= Qnil
;
6948 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6958 /* Handles the XEvent EVENT on display DISPLAY.
6959 This is used for event loops outside the normal event handling,
6960 i.e. looping while a popup menu or a dialog is posted.
6962 Returns the value handle_one_xevent sets in the finish argument. */
6964 x_dispatch_event (event
, display
)
6968 struct x_display_info
*dpyinfo
;
6969 int finish
= X_EVENT_NORMAL
;
6971 dpyinfo
= x_display_info_for_display (display
);
6974 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6980 /* Read events coming from the X server.
6981 This routine is called by the SIGIO handler.
6982 We return as soon as there are no more events to be read.
6984 We return the number of characters stored into the buffer,
6985 thus pretending to be `read'.
6987 EXPECTED is nonzero if the caller knows input is available. */
6990 XTread_socket (sd
, expected
, hold_quit
)
6993 struct input_event
*hold_quit
;
6997 int event_found
= 0;
6998 struct x_display_info
*dpyinfo
;
7000 if (interrupt_input_blocked
)
7002 interrupt_input_pending
= 1;
7006 interrupt_input_pending
= 0;
7009 /* So people can tell when we have read the available input. */
7010 input_signal_count
++;
7014 /* Find the display we are supposed to read input for.
7015 It's the one communicating on descriptor SD. */
7016 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
7018 #if 0 /* This ought to be unnecessary; let's verify it. */
7020 /* If available, Xlib uses FIOSNBIO to make the socket
7021 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
7022 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
7023 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
7024 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
7025 #endif /* ! defined (FIOSNBIO) */
7028 #if 0 /* This code can't be made to work, with multiple displays,
7029 and appears not to be used on any system any more.
7030 Also keyboard.c doesn't turn O_NDELAY on and off
7031 for X connections. */
7034 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
7036 extern int read_alarm_should_throw
;
7037 read_alarm_should_throw
= 1;
7038 XPeekEvent (dpyinfo
->display
, &event
);
7039 read_alarm_should_throw
= 0;
7041 #endif /* HAVE_SELECT */
7045 /* For debugging, this gives a way to fake an I/O error. */
7046 if (dpyinfo
== XTread_socket_fake_io_error
)
7048 XTread_socket_fake_io_error
= 0;
7049 x_io_error_quitter (dpyinfo
->display
);
7054 struct input_event inev
;
7056 /* We don't need to EVENT_INIT (inev) here, as
7057 x_session_check_input copies an entire input_event. */
7058 if (x_session_check_input (&inev
))
7060 kbd_buffer_store_event_hold (&inev
, hold_quit
);
7068 while (XPending (dpyinfo
->display
))
7072 XNextEvent (dpyinfo
->display
, &event
);
7075 /* Filter events for the current X input method. */
7076 if (x_filter_event (dpyinfo
, &event
))
7081 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
7083 if (finish
== X_EVENT_GOTO_OUT
)
7086 #endif /* not USE_GTK */
7091 /* For GTK we must use the GTK event loop. But XEvents gets passed
7092 to our filter function above, and then to the big event switch.
7093 We use a bunch of globals to communicate with our filter function,
7094 that is kind of ugly, but it works.
7096 There is no way to do one display at the time, GTK just does events
7097 from all displays. */
7099 while (gtk_events_pending ())
7101 current_count
= count
;
7102 current_hold_quit
= hold_quit
;
7104 gtk_main_iteration ();
7106 count
= current_count
;
7108 current_hold_quit
= 0;
7110 if (current_finish
== X_EVENT_GOTO_OUT
)
7113 #endif /* USE_GTK */
7117 /* On some systems, an X bug causes Emacs to get no more events
7118 when the window is destroyed. Detect that. (1994.) */
7121 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7122 One XNOOP in 100 loops will make Emacs terminate.
7123 B. Bretthauer, 1994 */
7125 if (x_noop_count
>= 100)
7129 if (next_noop_dpyinfo
== 0)
7130 next_noop_dpyinfo
= x_display_list
;
7132 XNoOp (next_noop_dpyinfo
->display
);
7134 /* Each time we get here, cycle through the displays now open. */
7135 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7139 /* If the focus was just given to an auto-raising frame,
7141 /* ??? This ought to be able to handle more than one such frame. */
7142 if (pending_autoraise_frame
)
7144 x_raise_frame (pending_autoraise_frame
);
7145 pending_autoraise_frame
= 0;
7157 /***********************************************************************
7159 ***********************************************************************/
7161 /* Set clipping for output in glyph row ROW. W is the window in which
7162 we operate. GC is the graphics context to set clipping in.
7164 ROW may be a text row or, e.g., a mode line. Text rows must be
7165 clipped to the interior of the window dedicated to text display,
7166 mode lines must be clipped to the whole window. */
7169 x_clip_to_row (w
, row
, area
, gc
)
7171 struct glyph_row
*row
;
7175 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7176 XRectangle clip_rect
;
7177 int window_x
, window_y
, window_width
;
7179 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7181 clip_rect
.x
= window_x
;
7182 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7183 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7184 clip_rect
.width
= window_width
;
7185 clip_rect
.height
= row
->visible_height
;
7187 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7191 /* Draw a hollow box cursor on window W in glyph row ROW. */
7194 x_draw_hollow_cursor (w
, row
)
7196 struct glyph_row
*row
;
7198 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7199 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7200 Display
*dpy
= FRAME_X_DISPLAY (f
);
7203 struct glyph
*cursor_glyph
;
7206 /* Get the glyph the cursor is on. If we can't tell because
7207 the current matrix is invalid or such, give up. */
7208 cursor_glyph
= get_phys_cursor_glyph (w
);
7209 if (cursor_glyph
== NULL
)
7212 /* Compute frame-relative coordinates for phys cursor. */
7213 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7214 wd
= w
->phys_cursor_width
;
7216 /* The foreground of cursor_gc is typically the same as the normal
7217 background color, which can cause the cursor box to be invisible. */
7218 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7219 if (dpyinfo
->scratch_cursor_gc
)
7220 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7222 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7223 GCForeground
, &xgcv
);
7224 gc
= dpyinfo
->scratch_cursor_gc
;
7226 /* Set clipping, draw the rectangle, and reset clipping again. */
7227 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7228 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7229 XSetClipMask (dpy
, gc
, None
);
7233 /* Draw a bar cursor on window W in glyph row ROW.
7235 Implementation note: One would like to draw a bar cursor with an
7236 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7237 Unfortunately, I didn't find a font yet that has this property set.
7241 x_draw_bar_cursor (w
, row
, width
, kind
)
7243 struct glyph_row
*row
;
7245 enum text_cursor_kinds kind
;
7247 struct frame
*f
= XFRAME (w
->frame
);
7248 struct glyph
*cursor_glyph
;
7250 /* If cursor is out of bounds, don't draw garbage. This can happen
7251 in mini-buffer windows when switching between echo area glyphs
7253 cursor_glyph
= get_phys_cursor_glyph (w
);
7254 if (cursor_glyph
== NULL
)
7257 /* If on an image, draw like a normal cursor. That's usually better
7258 visible than drawing a bar, esp. if the image is large so that
7259 the bar might not be in the window. */
7260 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7262 struct glyph_row
*row
;
7263 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7264 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7268 Display
*dpy
= FRAME_X_DISPLAY (f
);
7269 Window window
= FRAME_X_WINDOW (f
);
7270 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7271 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7272 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7275 /* If the glyph's background equals the color we normally draw
7276 the bar cursor in, the bar cursor in its normal color is
7277 invisible. Use the glyph's foreground color instead in this
7278 case, on the assumption that the glyph's colors are chosen so
7279 that the glyph is legible. */
7280 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7281 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7283 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7284 xgcv
.graphics_exposures
= 0;
7287 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7290 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7291 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7295 width
= FRAME_CURSOR_WIDTH (f
);
7296 width
= min (cursor_glyph
->pixel_width
, width
);
7298 w
->phys_cursor_width
= width
;
7299 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7301 if (kind
== BAR_CURSOR
)
7302 XFillRectangle (dpy
, window
, gc
,
7303 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7304 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7305 width
, row
->height
);
7307 XFillRectangle (dpy
, window
, gc
,
7308 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7309 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7310 row
->height
- width
),
7311 cursor_glyph
->pixel_width
,
7314 XSetClipMask (dpy
, gc
, None
);
7319 /* RIF: Define cursor CURSOR on frame F. */
7322 x_define_frame_cursor (f
, cursor
)
7326 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7330 /* RIF: Clear area on frame F. */
7333 x_clear_frame_area (f
, x
, y
, width
, height
)
7335 int x
, y
, width
, height
;
7337 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7338 x
, y
, width
, height
, False
);
7342 /* RIF: Draw cursor on window W. */
7345 x_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
7347 struct glyph_row
*glyph_row
;
7349 int cursor_type
, cursor_width
;
7352 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7356 w
->phys_cursor_type
= cursor_type
;
7357 w
->phys_cursor_on_p
= 1;
7359 if (glyph_row
->exact_window_width_line_p
7360 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
7362 glyph_row
->cursor_in_fringe_p
= 1;
7363 draw_fringe_bitmap (w
, glyph_row
, 0);
7366 switch (cursor_type
)
7368 case HOLLOW_BOX_CURSOR
:
7369 x_draw_hollow_cursor (w
, glyph_row
);
7372 case FILLED_BOX_CURSOR
:
7373 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7377 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7381 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7385 w
->phys_cursor_width
= 0;
7393 if (w
== XWINDOW (f
->selected_window
))
7394 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7395 xic_set_preeditarea (w
, x
, y
);
7400 if (updating_frame
!= f
)
7401 XFlush (FRAME_X_DISPLAY (f
));
7408 /* Make the x-window of frame F use the gnu icon bitmap. */
7411 x_bitmap_icon (f
, file
)
7417 if (FRAME_X_WINDOW (f
) == 0)
7420 /* Free up our existing icon bitmap and mask if any. */
7421 if (f
->output_data
.x
->icon_bitmap
> 0)
7422 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7423 f
->output_data
.x
->icon_bitmap
= 0;
7428 /* Use gtk_window_set_icon_from_file () if available,
7429 It's not restricted to bitmaps */
7430 if (xg_set_icon (f
, file
))
7432 #endif /* USE_GTK */
7433 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7434 x_create_bitmap_mask (f
, bitmap_id
);
7438 /* Create the GNU bitmap and mask if necessary. */
7439 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7443 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7445 if (xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7448 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7450 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7451 #endif /* USE_GTK */
7452 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
7454 /* If all else fails, use the (black and white) xbm image. */
7457 rc
= x_create_bitmap_from_data (f
, gnu_xbm_bits
,
7458 gnu_xbm_width
, gnu_xbm_height
);
7462 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7463 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7467 /* The first time we create the GNU bitmap and mask,
7468 this increments the ref-count one extra time.
7469 As a result, the GNU bitmap and mask are never freed.
7470 That way, we don't have to worry about allocating it again. */
7471 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7473 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7476 x_wm_set_icon_pixmap (f
, bitmap_id
);
7477 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7483 /* Make the x-window of frame F use a rectangle with text.
7484 Use ICON_NAME as the text. */
7487 x_text_icon (f
, icon_name
)
7491 if (FRAME_X_WINDOW (f
) == 0)
7497 text
.value
= (unsigned char *) icon_name
;
7498 text
.encoding
= XA_STRING
;
7500 text
.nitems
= strlen (icon_name
);
7501 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7503 #else /* not HAVE_X11R4 */
7504 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), icon_name
);
7505 #endif /* not HAVE_X11R4 */
7507 if (f
->output_data
.x
->icon_bitmap
> 0)
7508 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7509 f
->output_data
.x
->icon_bitmap
= 0;
7510 x_wm_set_icon_pixmap (f
, 0);
7515 #define X_ERROR_MESSAGE_SIZE 200
7517 /* If non-nil, this should be a string.
7518 It means catch X errors and store the error message in this string.
7520 The reason we use a stack is that x_catch_error/x_uncatch_error can
7521 be called from a signal handler.
7524 struct x_error_message_stack
{
7525 char string
[X_ERROR_MESSAGE_SIZE
];
7527 struct x_error_message_stack
*prev
;
7529 static struct x_error_message_stack
*x_error_message
;
7531 /* An X error handler which stores the error message in
7532 *x_error_message. This is called from x_error_handler if
7533 x_catch_errors is in effect. */
7536 x_error_catcher (display
, error
)
7540 XGetErrorText (display
, error
->error_code
,
7541 x_error_message
->string
,
7542 X_ERROR_MESSAGE_SIZE
);
7545 /* Begin trapping X errors for display DPY. Actually we trap X errors
7546 for all displays, but DPY should be the display you are actually
7549 After calling this function, X protocol errors no longer cause
7550 Emacs to exit; instead, they are recorded in the string
7551 stored in *x_error_message.
7553 Calling x_check_errors signals an Emacs error if an X error has
7554 occurred since the last call to x_catch_errors or x_check_errors.
7556 Calling x_uncatch_errors resumes the normal error handling. */
7558 void x_check_errors ();
7561 x_catch_errors (dpy
)
7564 struct x_error_message_stack
*data
= xmalloc (sizeof (*data
));
7566 /* Make sure any errors from previous requests have been dealt with. */
7570 data
->string
[0] = 0;
7571 data
->prev
= x_error_message
;
7572 x_error_message
= data
;
7575 /* Undo the last x_catch_errors call.
7576 DPY should be the display that was passed to x_catch_errors. */
7581 struct x_error_message_stack
*tmp
;
7585 /* The display may have been closed before this function is called.
7586 Check if it is still open before calling XSync. */
7587 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7588 XSync (x_error_message
->dpy
, False
);
7590 tmp
= x_error_message
;
7591 x_error_message
= x_error_message
->prev
;
7596 /* If any X protocol errors have arrived since the last call to
7597 x_catch_errors or x_check_errors, signal an Emacs error using
7598 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7601 x_check_errors (dpy
, format
)
7605 /* Make sure to catch any errors incurred so far. */
7608 if (x_error_message
->string
[0])
7610 char string
[X_ERROR_MESSAGE_SIZE
];
7611 bcopy (x_error_message
->string
, string
, X_ERROR_MESSAGE_SIZE
);
7612 x_uncatch_errors ();
7613 error (format
, string
);
7617 /* Nonzero if we had any X protocol errors
7618 since we did x_catch_errors on DPY. */
7621 x_had_errors_p (dpy
)
7624 /* Make sure to catch any errors incurred so far. */
7627 return x_error_message
->string
[0] != 0;
7630 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7633 x_clear_errors (dpy
)
7636 x_error_message
->string
[0] = 0;
7639 /* Close off all unclosed x_catch_errors calls. */
7642 x_fully_uncatch_errors ()
7644 while (x_error_message
)
7645 x_uncatch_errors ();
7648 /* Nonzero if x_catch_errors has been done and not yet canceled. */
7651 x_catching_errors ()
7653 return x_error_message
!= 0;
7657 static unsigned int x_wire_count
;
7660 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7665 /* Handle SIGPIPE, which can happen when the connection to a server
7666 simply goes away. SIGPIPE is handled by x_connection_signal.
7667 Don't need to do anything, because the write which caused the
7668 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7669 which will do the appropriate cleanup for us. */
7672 x_connection_signal (signalnum
) /* If we don't have an argument, */
7673 int signalnum
; /* some compilers complain in signal calls. */
7676 /* USG systems forget handlers when they are used;
7677 must reestablish each time */
7678 signal (signalnum
, x_connection_signal
);
7683 /************************************************************************
7685 ************************************************************************/
7687 /* Error message passed to x_connection_closed. */
7689 static char *error_msg
;
7691 /* Function installed as fatal_error_signal_hook in
7692 x_connection_closed. Print the X error message, and exit normally,
7693 instead of dumping core when XtCloseDisplay fails. */
7696 x_fatal_error_signal ()
7698 fprintf (stderr
, "%s\n", error_msg
);
7702 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7703 the text of an error message that lead to the connection loss. */
7706 x_connection_closed (dpy
, error_message
)
7708 char *error_message
;
7710 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7711 Lisp_Object frame
, tail
;
7713 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7714 strcpy (error_msg
, error_message
);
7715 handling_signal
= 0;
7717 /* Prevent being called recursively because of an error condition
7718 below. Otherwise, we might end up with printing ``can't find per
7719 display information'' in the recursive call instead of printing
7720 the original message here. */
7721 x_catch_errors (dpy
);
7723 /* We have to close the display to inform Xt that it doesn't
7724 exist anymore. If we don't, Xt will continue to wait for
7725 events from the display. As a consequence, a sequence of
7727 M-x make-frame-on-display RET :1 RET
7728 ...kill the new frame, so that we get an IO error...
7729 M-x make-frame-on-display RET :1 RET
7731 will indefinitely wait in Xt for events for display `:1', opened
7732 in the first class to make-frame-on-display.
7734 Closing the display is reported to lead to a bus error on
7735 OpenWindows in certain situations. I suspect that is a bug
7736 in OpenWindows. I don't know how to cicumvent it here. */
7738 #ifdef USE_X_TOOLKIT
7739 /* If DPYINFO is null, this means we didn't open the display
7740 in the first place, so don't try to close it. */
7743 extern void (*fatal_error_signal_hook
) P_ ((void));
7744 fatal_error_signal_hook
= x_fatal_error_signal
;
7745 XtCloseDisplay (dpy
);
7746 fatal_error_signal_hook
= NULL
;
7752 xg_display_close (dpyinfo
->display
);
7755 /* Indicate that this display is dead. */
7757 dpyinfo
->display
= 0;
7759 /* First delete frames whose mini-buffers are on frames
7760 that are on the dead display. */
7761 FOR_EACH_FRAME (tail
, frame
)
7763 Lisp_Object minibuf_frame
;
7765 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7766 if (FRAME_X_P (XFRAME (frame
))
7767 && FRAME_X_P (XFRAME (minibuf_frame
))
7768 && ! EQ (frame
, minibuf_frame
)
7769 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7770 Fdelete_frame (frame
, Qt
);
7773 /* Now delete all remaining frames on the dead display.
7774 We are now sure none of these is used as the mini-buffer
7775 for another frame that we need to delete. */
7776 FOR_EACH_FRAME (tail
, frame
)
7777 if (FRAME_X_P (XFRAME (frame
))
7778 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7780 /* Set this to t so that Fdelete_frame won't get confused
7781 trying to find a replacement. */
7782 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7783 Fdelete_frame (frame
, Qt
);
7787 x_delete_display (dpyinfo
);
7789 x_uncatch_errors ();
7791 if (x_display_list
== 0)
7793 fprintf (stderr
, "%s\n", error_msg
);
7794 shut_down_emacs (0, 0, Qnil
);
7798 /* Ordinary stack unwind doesn't deal with these. */
7800 sigunblock (sigmask (SIGIO
));
7802 sigunblock (sigmask (SIGALRM
));
7803 TOTALLY_UNBLOCK_INPUT
;
7805 clear_waiting_for_input ();
7806 error ("%s", error_msg
);
7809 /* We specifically use it before defining it, so that gcc doesn't inline it,
7810 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7811 static void x_error_quitter
P_ ((Display
*, XErrorEvent
*));
7813 /* This is the first-level handler for X protocol errors.
7814 It calls x_error_quitter or x_error_catcher. */
7817 x_error_handler (display
, error
)
7821 if (x_error_message
)
7822 x_error_catcher (display
, error
);
7824 x_error_quitter (display
, error
);
7828 /* This is the usual handler for X protocol errors.
7829 It kills all frames on the display that we got the error for.
7830 If that was the only one, it prints an error message and kills Emacs. */
7832 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7834 #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */
7835 #define NO_INLINE __attribute__((noinline))
7840 /* Some versions of GNU/Linux define noinline in their headers. */
7846 /* On older GCC versions, just putting x_error_quitter
7847 after x_error_handler prevents inlining into the former. */
7849 static void NO_INLINE
7850 x_error_quitter (display
, error
)
7854 char buf
[256], buf1
[356];
7856 /* Ignore BadName errors. They can happen because of fonts
7857 or colors that are not defined. */
7859 if (error
->error_code
== BadName
)
7862 /* Note that there is no real way portable across R3/R4 to get the
7863 original error handler. */
7865 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7866 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7867 buf
, error
->request_code
);
7868 x_connection_closed (display
, buf1
);
7872 /* This is the handler for X IO errors, always.
7873 It kills all frames on the display that we lost touch with.
7874 If that was the only one, it prints an error message and kills Emacs. */
7877 x_io_error_quitter (display
)
7882 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7883 x_connection_closed (display
, buf
);
7887 /* Changing the font of the frame. */
7889 /* Give frame F the font named FONTNAME as its default font, and
7890 return the full name of that font. FONTNAME may be a wildcard
7891 pattern; in that case, we choose some font that fits the pattern.
7892 The return value shows which font we chose. */
7895 x_new_font (f
, fontname
)
7897 register char *fontname
;
7899 struct font_info
*fontp
7900 = FS_LOAD_FONT (f
, 0, fontname
, -1);
7905 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
7906 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
7907 FRAME_FONTSET (f
) = -1;
7909 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
7910 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
7911 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
7913 compute_fringe_widths (f
, 1);
7915 /* Compute the scroll bar width in character columns. */
7916 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7918 int wid
= FRAME_COLUMN_WIDTH (f
);
7919 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7920 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7924 int wid
= FRAME_COLUMN_WIDTH (f
);
7925 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7928 /* Now make the frame display the given font. */
7929 if (FRAME_X_WINDOW (f
) != 0)
7931 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
7932 FRAME_FONT (f
)->fid
);
7933 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
7934 FRAME_FONT (f
)->fid
);
7935 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
7936 FRAME_FONT (f
)->fid
);
7938 /* Don't change the size of a tip frame; there's no point in
7939 doing it because it's done in Fx_show_tip, and it leads to
7940 problems because the tip frame has no widget. */
7941 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7942 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7945 return build_string (fontp
->full_name
);
7948 /* Give frame F the fontset named FONTSETNAME as its default font, and
7949 return the full name of that fontset. FONTSETNAME may be a wildcard
7950 pattern; in that case, we choose some fontset that fits the pattern.
7951 The return value shows which fontset we chose. */
7954 x_new_fontset (f
, fontsetname
)
7958 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
7964 if (FRAME_FONTSET (f
) == fontset
)
7965 /* This fontset is already set in frame F. There's nothing more
7967 return fontset_name (fontset
);
7969 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
7971 if (!STRINGP (result
))
7972 /* Can't load ASCII font. */
7975 /* Since x_new_font doesn't update any fontset information, do it now. */
7976 FRAME_FONTSET (f
) = fontset
;
7980 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7981 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7984 return build_string (fontsetname
);
7988 /***********************************************************************
7990 ***********************************************************************/
7996 /* XIM destroy callback function, which is called whenever the
7997 connection to input method XIM dies. CLIENT_DATA contains a
7998 pointer to the x_display_info structure corresponding to XIM. */
8001 xim_destroy_callback (xim
, client_data
, call_data
)
8003 XPointer client_data
;
8006 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
8007 Lisp_Object frame
, tail
;
8011 /* No need to call XDestroyIC.. */
8012 FOR_EACH_FRAME (tail
, frame
)
8014 struct frame
*f
= XFRAME (frame
);
8015 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
8017 FRAME_XIC (f
) = NULL
;
8018 xic_free_xfontset (f
);
8022 /* No need to call XCloseIM. */
8023 dpyinfo
->xim
= NULL
;
8024 XFree (dpyinfo
->xim_styles
);
8028 #endif /* HAVE_X11R6 */
8031 /* This isn't prototyped in OSF 5.0 or 5.1a. */
8032 extern char *XSetIMValues
P_ ((XIM
, ...));
8035 /* Open the connection to the XIM server on display DPYINFO.
8036 RESOURCE_NAME is the resource name Emacs uses. */
8039 xim_open_dpy (dpyinfo
, resource_name
)
8040 struct x_display_info
*dpyinfo
;
8041 char *resource_name
;
8048 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
8055 XIMCallback destroy
;
8058 /* Get supported styles and XIM values. */
8059 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
8062 destroy
.callback
= xim_destroy_callback
;
8063 destroy
.client_data
= (XPointer
)dpyinfo
;
8064 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8070 #endif /* HAVE_XIM */
8071 dpyinfo
->xim
= NULL
;
8075 #ifdef HAVE_X11R6_XIM
8079 struct x_display_info
*dpyinfo
;
8080 char *resource_name
;
8083 /* XIM instantiate callback function, which is called whenever an XIM
8084 server is available. DISPLAY is the display of the XIM.
8085 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8086 when the callback was registered. */
8089 xim_instantiate_callback (display
, client_data
, call_data
)
8091 XPointer client_data
;
8094 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8095 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8097 /* We don't support multiple XIM connections. */
8101 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8103 /* Create XIC for the existing frames on the same display, as long
8104 as they have no XIC. */
8105 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8107 Lisp_Object tail
, frame
;
8110 FOR_EACH_FRAME (tail
, frame
)
8112 struct frame
*f
= XFRAME (frame
);
8114 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8115 if (FRAME_XIC (f
) == NULL
)
8117 create_frame_xic (f
);
8118 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8119 xic_set_statusarea (f
);
8120 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8122 struct window
*w
= XWINDOW (f
->selected_window
);
8123 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8132 #endif /* HAVE_X11R6_XIM */
8135 /* Open a connection to the XIM server on display DPYINFO.
8136 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8137 connection only at the first time. On X11R6, open the connection
8138 in the XIM instantiate callback function. */
8141 xim_initialize (dpyinfo
, resource_name
)
8142 struct x_display_info
*dpyinfo
;
8143 char *resource_name
;
8148 #ifdef HAVE_X11R6_XIM
8149 struct xim_inst_t
*xim_inst
;
8152 dpyinfo
->xim
= NULL
;
8153 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8154 xim_inst
->dpyinfo
= dpyinfo
;
8155 len
= strlen (resource_name
);
8156 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8157 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
8158 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8159 resource_name
, EMACS_CLASS
,
8160 xim_instantiate_callback
,
8161 /* This is XPointer in XFree86
8162 but (XPointer *) on Tru64, at
8163 least, hence the configure test. */
8164 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8165 #else /* not HAVE_X11R6_XIM */
8166 dpyinfo
->xim
= NULL
;
8167 xim_open_dpy (dpyinfo
, resource_name
);
8168 #endif /* not HAVE_X11R6_XIM */
8172 #endif /* HAVE_XIM */
8173 dpyinfo
->xim
= NULL
;
8177 /* Close the connection to the XIM server on display DPYINFO. */
8180 xim_close_dpy (dpyinfo
)
8181 struct x_display_info
*dpyinfo
;
8186 #ifdef HAVE_X11R6_XIM
8187 if (dpyinfo
->display
)
8188 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8190 xim_instantiate_callback
, NULL
);
8191 #endif /* not HAVE_X11R6_XIM */
8192 if (dpyinfo
->display
)
8193 XCloseIM (dpyinfo
->xim
);
8194 dpyinfo
->xim
= NULL
;
8195 XFree (dpyinfo
->xim_styles
);
8197 #endif /* HAVE_XIM */
8200 #endif /* not HAVE_X11R6_XIM */
8204 /* Calculate the absolute position in frame F
8205 from its current recorded position values and gravity. */
8208 x_calc_absolute_position (f
)
8211 int flags
= f
->size_hint_flags
;
8213 /* We have nothing to do if the current position
8214 is already for the top-left corner. */
8215 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8218 /* Treat negative positions as relative to the leftmost bottommost
8219 position that fits on the screen. */
8220 if (flags
& XNegative
)
8221 f
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
8222 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
);
8225 int height
= FRAME_PIXEL_HEIGHT (f
);
8227 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8228 /* Something is fishy here. When using Motif, starting Emacs with
8229 `-g -0-0', the frame appears too low by a few pixels.
8231 This seems to be so because initially, while Emacs is starting,
8232 the column widget's height and the frame's pixel height are
8233 different. The column widget's height is the right one. In
8234 later invocations, when Emacs is up, the frame's pixel height
8237 It's not obvious where the initial small difference comes from.
8238 2000-12-01, gerd. */
8240 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8243 if (flags
& YNegative
)
8244 f
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
- height
+ f
->top_pos
);
8247 /* The left_pos and top_pos
8248 are now relative to the top and left screen edges,
8249 so the flags should correspond. */
8250 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8253 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8254 to really change the position, and 0 when calling from
8255 x_make_frame_visible (in that case, XOFF and YOFF are the current
8256 position values). It is -1 when calling from x_set_frame_parameters,
8257 which means, do adjust for borders but don't change the gravity. */
8260 x_set_offset (f
, xoff
, yoff
, change_gravity
)
8262 register int xoff
, yoff
;
8265 int modified_top
, modified_left
;
8267 if (change_gravity
!= 0)
8269 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8270 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8274 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8276 f
->size_hint_flags
|= XNegative
;
8278 f
->size_hint_flags
|= YNegative
;
8279 f
->win_gravity
= NorthWestGravity
;
8281 x_calc_absolute_position (f
);
8284 x_wm_set_size_hint (f
, (long) 0, 0);
8286 modified_left
= f
->left_pos
;
8287 modified_top
= f
->top_pos
;
8289 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8291 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8292 than the WM decorations. So we use the calculated offset instead
8293 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8294 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8295 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8298 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8299 modified_left
, modified_top
);
8301 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8302 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8305 /* change_gravity is non-zero when this function is called from Lisp to
8306 programmatically move a frame. In that case, we call
8307 x_check_expected_move to discover if we have a "Type A" or "Type B"
8308 window manager, and, for a "Type A" window manager, adjust the position
8311 We call x_check_expected_move if a programmatic move occurred, and
8312 either the window manager type (A/B) is unknown or it is Type A but we
8313 need to compute the top/left offset adjustment for this frame. */
8315 if (change_gravity
!= 0 &&
8316 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8317 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8318 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8319 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8320 x_check_expected_move (f
, modified_left
, modified_top
);
8325 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8326 on the root window for frame F contains ATOMNAME.
8327 This is how a WM check shall be done according to the Window Manager
8328 Specification/Extended Window Manager Hints at
8329 http://freedesktop.org/wiki/Standards_2fwm_2dspec. */
8332 wm_supports (f
, atomname
)
8334 const char *atomname
;
8337 unsigned long actual_size
, bytes_remaining
;
8338 int i
, rc
, actual_format
;
8340 Window wmcheck_window
;
8341 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8342 Window target_window
= dpyinfo
->root_window
;
8343 long max_len
= 65536;
8344 Display
*dpy
= FRAME_X_DISPLAY (f
);
8345 unsigned char *tmp_data
= NULL
;
8346 Atom target_type
= XA_WINDOW
;
8351 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTING_WM_CHECK", False
);
8353 x_catch_errors (dpy
);
8354 rc
= XGetWindowProperty (dpy
, target_window
,
8355 prop_atom
, 0, max_len
, False
, target_type
,
8356 &actual_type
, &actual_format
, &actual_size
,
8357 &bytes_remaining
, &tmp_data
);
8359 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8361 if (tmp_data
) XFree (tmp_data
);
8362 x_uncatch_errors ();
8367 wmcheck_window
= *(Window
*) tmp_data
;
8370 /* Check if window exists. */
8371 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8373 if (x_had_errors_p (dpy
))
8375 x_uncatch_errors ();
8380 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8382 /* Window changed, reload atoms */
8383 if (dpyinfo
->net_supported_atoms
!= NULL
)
8384 XFree (dpyinfo
->net_supported_atoms
);
8385 dpyinfo
->net_supported_atoms
= NULL
;
8386 dpyinfo
->nr_net_supported_atoms
= 0;
8387 dpyinfo
->net_supported_window
= 0;
8389 target_type
= XA_ATOM
;
8390 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTED", False
);
8392 rc
= XGetWindowProperty (dpy
, target_window
,
8393 prop_atom
, 0, max_len
, False
, target_type
,
8394 &actual_type
, &actual_format
, &actual_size
,
8395 &bytes_remaining
, &tmp_data
);
8397 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8399 if (tmp_data
) XFree (tmp_data
);
8400 x_uncatch_errors ();
8405 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8406 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8407 dpyinfo
->net_supported_window
= wmcheck_window
;
8411 want_atom
= XInternAtom (dpy
, atomname
, False
);
8413 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8414 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8416 x_uncatch_errors ();
8422 /* Do fullscreen as specified in extended window manager hints */
8425 do_ewmh_fullscreen (f
)
8428 int have_net_atom
= wm_supports (f
, "_NET_WM_STATE");
8430 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8431 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8433 have_net_atom
= wm_supports (f
, "_NET_WM_STATE_FULLSCREEN");
8438 const char *atom
= "_NET_WM_STATE";
8439 const char *fs
= "_NET_WM_STATE_FULLSCREEN";
8440 const char *fw
= "_NET_WM_STATE_MAXIMIZED_HORZ";
8441 const char *fh
= "_NET_WM_STATE_MAXIMIZED_VERT";
8442 const char *what
= NULL
;
8444 XSETFRAME (frame
, f
);
8446 /* If there are _NET_ atoms we assume we have extended window manager
8448 switch (f
->want_fullscreen
)
8450 case FULLSCREEN_BOTH
:
8453 case FULLSCREEN_WIDTH
:
8456 case FULLSCREEN_HEIGHT
:
8461 if (what
!= NULL
&& !wm_supports (f
, what
)) return 0;
8464 Fx_send_client_event (frame
, make_number (0), frame
,
8465 make_unibyte_string (atom
, strlen (atom
)),
8467 Fcons (make_number (0), /* Remove */
8469 (make_unibyte_string (fs
,
8472 Fx_send_client_event (frame
, make_number (0), frame
,
8473 make_unibyte_string (atom
, strlen (atom
)),
8475 Fcons (make_number (0), /* Remove */
8477 (make_unibyte_string (fh
,
8480 Fx_send_client_event (frame
, make_number (0), frame
,
8481 make_unibyte_string (atom
, strlen (atom
)),
8483 Fcons (make_number (0), /* Remove */
8485 (make_unibyte_string (fw
,
8488 f
->want_fullscreen
= FULLSCREEN_NONE
;
8490 Fx_send_client_event (frame
, make_number (0), frame
,
8491 make_unibyte_string (atom
, strlen (atom
)),
8493 Fcons (make_number (1), /* Add */
8495 (make_unibyte_string (what
,
8500 return have_net_atom
;
8504 XTfullscreen_hook (f
)
8507 if (f
->async_visible
)
8510 do_ewmh_fullscreen (f
);
8517 /* Check if we need to resize the frame due to a fullscreen request.
8518 If so needed, resize the frame. */
8520 x_check_fullscreen (f
)
8523 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
8525 int width
, height
, ign
;
8527 if (do_ewmh_fullscreen (f
))
8530 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8532 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
8534 /* We do not need to move the window, it shall be taken care of
8535 when setting WM manager hints.
8536 If the frame is visible already, the position is checked by
8537 x_check_expected_move. */
8538 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8540 change_frame_size (f
, height
, width
, 0, 1, 0);
8541 SET_FRAME_GARBAGED (f
);
8542 cancel_mouse_face (f
);
8544 /* Wait for the change of frame size to occur */
8545 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
8550 /* This function is called by x_set_offset to determine whether the window
8551 manager interfered with the positioning of the frame. Type A window
8552 managers position the surrounding window manager decorations a small
8553 amount above and left of the user-supplied position. Type B window
8554 managers position the surrounding window manager decorations at the
8555 user-specified position. If we detect a Type A window manager, we
8556 compensate by moving the window right and down by the proper amount. */
8559 x_check_expected_move (f
, expected_left
, expected_top
)
8564 int current_left
= 0, current_top
= 0;
8566 /* x_real_positions returns the left and top offsets of the outermost
8567 window manager window around the frame. */
8569 x_real_positions (f
, ¤t_left
, ¤t_top
);
8571 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8573 /* It's a "Type A" window manager. */
8578 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8579 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8580 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8582 /* Now fix the mispositioned frame's location. */
8584 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8585 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8587 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8588 adjusted_left
, adjusted_top
);
8590 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8593 /* It's a "Type B" window manager. We don't have to adjust the
8594 frame's position. */
8596 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8600 /* Wait for XGetGeometry to return up-to-date position information for a
8601 recently-moved frame. Call this immediately after calling XMoveWindow.
8602 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8603 frame has been moved to, so we use a fuzzy position comparison instead
8604 of an exact comparison. */
8607 x_sync_with_move (f
, left
, top
, fuzzy
)
8609 int left
, top
, fuzzy
;
8613 while (count
++ < 50)
8615 int current_left
= 0, current_top
= 0;
8617 /* In theory, this call to XSync only needs to happen once, but in
8618 practice, it doesn't seem to work, hence the need for the surrounding
8621 XSync (FRAME_X_DISPLAY (f
), False
);
8622 x_real_positions (f
, ¤t_left
, ¤t_top
);
8626 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8629 if (abs (current_left
- left
) <= 10 && abs (current_top
- top
) <= 40)
8632 else if (current_left
== left
&& current_top
== top
)
8636 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8637 will then return up-to-date position info. */
8639 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8643 /* Change the size of frame F's X window to COLS/ROWS in the case F
8644 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8645 top-left-corner window gravity for this size change and subsequent
8646 size changes. Otherwise we leave the window gravity unchanged. */
8649 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
8654 int pixelwidth
, pixelheight
;
8656 check_frame_size (f
, &rows
, &cols
);
8657 f
->scroll_bar_actual_width
8658 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8660 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
8661 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
8662 : (FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
)));
8664 compute_fringe_widths (f
, 0);
8666 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
8667 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
8669 f
->win_gravity
= NorthWestGravity
;
8670 x_wm_set_size_hint (f
, (long) 0, 0);
8672 XSync (FRAME_X_DISPLAY (f
), False
);
8673 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8674 pixelwidth
, pixelheight
);
8676 /* Now, strictly speaking, we can't be sure that this is accurate,
8677 but the window manager will get around to dealing with the size
8678 change request eventually, and we'll hear how it went when the
8679 ConfigureNotify event gets here.
8681 We could just not bother storing any of this information here,
8682 and let the ConfigureNotify event set everything up, but that
8683 might be kind of confusing to the Lisp code, since size changes
8684 wouldn't be reported in the frame parameters until some random
8685 point in the future when the ConfigureNotify event arrives.
8687 We pass 1 for DELAY since we can't run Lisp code inside of
8689 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8690 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8691 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8693 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8694 receive in the ConfigureNotify event; if we get what we asked
8695 for, then the event won't cause the screen to become garbaged, so
8696 we have to make sure to do it here. */
8697 SET_FRAME_GARBAGED (f
);
8699 XFlush (FRAME_X_DISPLAY (f
));
8703 /* Call this to change the size of frame F's x-window.
8704 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8705 for this size change and subsequent size changes.
8706 Otherwise we leave the window gravity unchanged. */
8709 x_set_window_size (f
, change_gravity
, cols
, rows
)
8717 if (FRAME_GTK_WIDGET (f
))
8718 xg_frame_set_char_size (f
, cols
, rows
);
8720 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8723 if (f
->output_data
.x
->widget
!= NULL
)
8725 /* The x and y position of the widget is clobbered by the
8726 call to XtSetValues within EmacsFrameSetCharSize.
8727 This is a real kludge, but I don't understand Xt so I can't
8728 figure out a correct fix. Can anyone else tell me? -- rms. */
8729 int xpos
= f
->output_data
.x
->widget
->core
.x
;
8730 int ypos
= f
->output_data
.x
->widget
->core
.y
;
8731 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
8732 f
->output_data
.x
->widget
->core
.x
= xpos
;
8733 f
->output_data
.x
->widget
->core
.y
= ypos
;
8736 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8738 #else /* not USE_X_TOOLKIT */
8740 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8742 #endif /* not USE_X_TOOLKIT */
8744 /* If cursor was outside the new size, mark it as off. */
8745 mark_window_cursors_off (XWINDOW (f
->root_window
));
8747 /* Clear out any recollection of where the mouse highlighting was,
8748 since it might be in a place that's outside the new frame size.
8749 Actually checking whether it is outside is a pain in the neck,
8750 so don't try--just let the highlighting be done afresh with new size. */
8751 cancel_mouse_face (f
);
8756 /* Mouse warping. */
8759 x_set_mouse_position (f
, x
, y
)
8765 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8766 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8768 if (pix_x
< 0) pix_x
= 0;
8769 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8771 if (pix_y
< 0) pix_y
= 0;
8772 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8776 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8777 0, 0, 0, 0, pix_x
, pix_y
);
8781 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8784 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
8790 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8791 0, 0, 0, 0, pix_x
, pix_y
);
8795 /* focus shifting, raising and lowering. */
8798 x_focus_on_frame (f
)
8801 #if 0 /* This proves to be unpleasant. */
8805 /* I don't think that the ICCCM allows programs to do things like this
8806 without the interaction of the window manager. Whatever you end up
8807 doing with this code, do it to x_unfocus_frame too. */
8808 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8809 RevertToPointerRoot
, CurrentTime
);
8818 /* Look at the remarks in x_focus_on_frame. */
8819 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8820 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8821 RevertToPointerRoot
, CurrentTime
);
8825 /* Raise frame F. */
8832 if (f
->async_visible
)
8833 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8835 XFlush (FRAME_X_DISPLAY (f
));
8839 /* Lower frame F. */
8845 if (f
->async_visible
)
8848 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8849 XFlush (FRAME_X_DISPLAY (f
));
8855 XTframe_raise_lower (f
, raise_flag
)
8861 /* The following code is needed for `raise-frame' to work on
8862 some versions of metacity; see Window Manager
8863 Specification/Extended Window Manager Hints at
8864 http://freedesktop.org/wiki/Standards_2fwm_2dspec */
8867 /* However, on other versions (metacity 2.17.2-1.fc7), it
8868 reportedly causes hangs when resizing frames. */
8870 const char *atom
= "_NET_ACTIVE_WINDOW";
8871 if (f
->async_visible
&& wm_supports (f
, atom
))
8874 XSETFRAME (frame
, f
);
8875 Fx_send_client_event (frame
, make_number (0), frame
,
8876 make_unibyte_string (atom
, strlen (atom
)),
8878 Fcons (make_number (1),
8879 Fcons (make_number (last_user_time
),
8890 /* Change of visibility. */
8892 /* This tries to wait until the frame is really visible.
8893 However, if the window manager asks the user where to position
8894 the frame, this will return before the user finishes doing that.
8895 The frame will not actually be visible at that time,
8896 but it will become visible later when the window manager
8897 finishes with it. */
8900 x_make_frame_visible (f
)
8904 int original_top
, original_left
;
8905 int retry_count
= 2;
8911 type
= x_icon_type (f
);
8913 x_bitmap_icon (f
, type
);
8915 if (! FRAME_VISIBLE_P (f
))
8917 /* We test FRAME_GARBAGED_P here to make sure we don't
8918 call x_set_offset a second time
8919 if we get to x_make_frame_visible a second time
8920 before the window gets really visible. */
8921 if (! FRAME_ICONIFIED_P (f
)
8922 && ! f
->output_data
.x
->asked_for_visible
)
8923 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8925 f
->output_data
.x
->asked_for_visible
= 1;
8927 if (! EQ (Vx_no_window_manager
, Qt
))
8928 x_wm_set_window_state (f
, NormalState
);
8929 #ifdef USE_X_TOOLKIT
8930 /* This was XtPopup, but that did nothing for an iconified frame. */
8931 XtMapWidget (f
->output_data
.x
->widget
);
8932 #else /* not USE_X_TOOLKIT */
8934 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8935 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8937 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8938 #endif /* not USE_GTK */
8939 #endif /* not USE_X_TOOLKIT */
8940 #if 0 /* This seems to bring back scroll bars in the wrong places
8941 if the window configuration has changed. They seem
8942 to come back ok without this. */
8943 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8944 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8948 XFlush (FRAME_X_DISPLAY (f
));
8950 /* Synchronize to ensure Emacs knows the frame is visible
8951 before we do anything else. We do this loop with input not blocked
8952 so that incoming events are handled. */
8956 /* This must be before UNBLOCK_INPUT
8957 since events that arrive in response to the actions above
8958 will set it when they are handled. */
8959 int previously_visible
= f
->output_data
.x
->has_been_visible
;
8961 original_left
= f
->left_pos
;
8962 original_top
= f
->top_pos
;
8964 /* This must come after we set COUNT. */
8967 /* We unblock here so that arriving X events are processed. */
8969 /* Now move the window back to where it was "supposed to be".
8970 But don't do it if the gravity is negative.
8971 When the gravity is negative, this uses a position
8972 that is 3 pixels too low. Perhaps that's really the border width.
8974 Don't do this if the window has never been visible before,
8975 because the window manager may choose the position
8976 and we don't want to override it. */
8978 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
8979 && f
->win_gravity
== NorthWestGravity
8980 && previously_visible
)
8984 unsigned int width
, height
, border
, depth
;
8988 /* On some window managers (such as FVWM) moving an existing
8989 window, even to the same place, causes the window manager
8990 to introduce an offset. This can cause the window to move
8991 to an unexpected location. Check the geometry (a little
8992 slow here) and then verify that the window is in the right
8993 place. If the window is not in the right place, move it
8994 there, and take the potential window manager hit. */
8995 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8996 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
8998 if (original_left
!= x
|| original_top
!= y
)
8999 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9000 original_left
, original_top
);
9005 XSETFRAME (frame
, f
);
9007 /* Wait until the frame is visible. Process X events until a
9008 MapNotify event has been seen, or until we think we won't get a
9009 MapNotify at all.. */
9010 for (count
= input_signal_count
+ 10;
9011 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9013 /* Force processing of queued events. */
9016 /* Machines that do polling rather than SIGIO have been
9017 observed to go into a busy-wait here. So we'll fake an
9018 alarm signal to let the handler know that there's something
9019 to be read. We used to raise a real alarm, but it seems
9020 that the handler isn't always enabled here. This is
9022 if (input_polling_used ())
9024 /* It could be confusing if a real alarm arrives while
9025 processing the fake one. Turn it off and let the
9026 handler reset it. */
9027 extern void poll_for_input_1
P_ ((void));
9028 int old_poll_suppress_count
= poll_suppress_count
;
9029 poll_suppress_count
= 1;
9030 poll_for_input_1 ();
9031 poll_suppress_count
= old_poll_suppress_count
;
9034 /* See if a MapNotify event has been processed. */
9035 FRAME_SAMPLE_VISIBILITY (f
);
9040 (let ((f (selected-frame)))
9044 the frame is not raised with various window managers on
9045 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9046 unknown reason, the call to XtMapWidget is completely ignored.
9047 Mapping the widget a second time works. */
9049 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9054 /* Change from mapped state to withdrawn state. */
9056 /* Make the frame visible (mapped and not iconified). */
9059 x_make_frame_invisible (f
)
9064 /* Use the frame's outermost window, not the one we normally draw on. */
9065 window
= FRAME_OUTER_WINDOW (f
);
9067 /* Don't keep the highlight on an invisible frame. */
9068 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9069 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9071 #if 0/* This might add unreliability; I don't trust it -- rms. */
9072 if (! f
->async_visible
&& ! f
->async_iconified
)
9078 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9079 that the current position of the window is user-specified, rather than
9080 program-specified, so that when the window is mapped again, it will be
9081 placed at the same location, without forcing the user to position it
9082 by hand again (they have already done that once for this window.) */
9083 x_wm_set_size_hint (f
, (long) 0, 1);
9086 if (FRAME_GTK_OUTER_WIDGET (f
))
9087 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9093 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9094 DefaultScreen (FRAME_X_DISPLAY (f
))))
9096 UNBLOCK_INPUT_RESIGNAL
;
9097 error ("Can't notify window manager of window withdrawal");
9099 #else /* ! defined (HAVE_X11R4) */
9101 /* Tell the window manager what we're going to do. */
9102 if (! EQ (Vx_no_window_manager
, Qt
))
9106 unmap
.xunmap
.type
= UnmapNotify
;
9107 unmap
.xunmap
.window
= window
;
9108 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
9109 unmap
.xunmap
.from_configure
= False
;
9110 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9111 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9113 SubstructureRedirectMaskSubstructureNotifyMask
,
9116 UNBLOCK_INPUT_RESIGNAL
;
9117 error ("Can't notify window manager of withdrawal");
9121 /* Unmap the window ourselves. Cheeky! */
9122 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
9123 #endif /* ! defined (HAVE_X11R4) */
9126 /* We can't distinguish this from iconification
9127 just by the event that we get from the server.
9128 So we can't win using the usual strategy of letting
9129 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9130 and synchronize with the server to make sure we agree. */
9132 FRAME_ICONIFIED_P (f
) = 0;
9133 f
->async_visible
= 0;
9134 f
->async_iconified
= 0;
9141 /* Change window state from mapped to iconified. */
9150 /* Don't keep the highlight on an invisible frame. */
9151 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9152 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9154 if (f
->async_iconified
)
9159 FRAME_SAMPLE_VISIBILITY (f
);
9161 type
= x_icon_type (f
);
9163 x_bitmap_icon (f
, type
);
9166 if (FRAME_GTK_OUTER_WIDGET (f
))
9168 if (! FRAME_VISIBLE_P (f
))
9169 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9171 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9174 f
->async_iconified
= 1;
9175 f
->async_visible
= 0;
9181 #ifdef USE_X_TOOLKIT
9183 if (! FRAME_VISIBLE_P (f
))
9185 if (! EQ (Vx_no_window_manager
, Qt
))
9186 x_wm_set_window_state (f
, IconicState
);
9187 /* This was XtPopup, but that did nothing for an iconified frame. */
9188 XtMapWidget (f
->output_data
.x
->widget
);
9189 /* The server won't give us any event to indicate
9190 that an invisible frame was changed to an icon,
9191 so we have to record it here. */
9194 f
->async_iconified
= 1;
9195 f
->async_visible
= 0;
9200 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9201 XtWindow (f
->output_data
.x
->widget
),
9202 DefaultScreen (FRAME_X_DISPLAY (f
)));
9206 error ("Can't notify window manager of iconification");
9208 f
->async_iconified
= 1;
9209 f
->async_visible
= 0;
9213 XFlush (FRAME_X_DISPLAY (f
));
9215 #else /* not USE_X_TOOLKIT */
9217 /* Make sure the X server knows where the window should be positioned,
9218 in case the user deiconifies with the window manager. */
9219 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
9220 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9222 /* Since we don't know which revision of X we're running, we'll use both
9223 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9225 /* X11R4: send a ClientMessage to the window manager using the
9226 WM_CHANGE_STATE type. */
9230 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9231 message
.xclient
.type
= ClientMessage
;
9232 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9233 message
.xclient
.format
= 32;
9234 message
.xclient
.data
.l
[0] = IconicState
;
9236 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9237 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9239 SubstructureRedirectMask
| SubstructureNotifyMask
,
9242 UNBLOCK_INPUT_RESIGNAL
;
9243 error ("Can't notify window manager of iconification");
9247 /* X11R3: set the initial_state field of the window manager hints to
9249 x_wm_set_window_state (f
, IconicState
);
9251 if (!FRAME_VISIBLE_P (f
))
9253 /* If the frame was withdrawn, before, we must map it. */
9254 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9257 f
->async_iconified
= 1;
9258 f
->async_visible
= 0;
9260 XFlush (FRAME_X_DISPLAY (f
));
9262 #endif /* not USE_X_TOOLKIT */
9266 /* Free X resources of frame F. */
9269 x_free_frame_resources (f
)
9272 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9274 struct scroll_bar
*b
;
9278 /* If a display connection is dead, don't try sending more
9279 commands to the X server. */
9280 if (dpyinfo
->display
)
9282 if (f
->output_data
.x
->icon_desc
)
9283 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9285 #ifdef USE_X_TOOLKIT
9286 /* Explicitly destroy the scroll bars of the frame. Without
9287 this, we get "BadDrawable" errors from the toolkit later on,
9288 presumably from expose events generated for the disappearing
9289 toolkit scroll bars. */
9290 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9292 b
= XSCROLL_BAR (bar
);
9293 x_scroll_bar_remove (b
);
9302 #ifdef USE_X_TOOLKIT
9303 if (f
->output_data
.x
->widget
)
9305 XtDestroyWidget (f
->output_data
.x
->widget
);
9306 f
->output_data
.x
->widget
= NULL
;
9308 /* Tooltips don't have widgets, only a simple X window, even if
9309 we are using a toolkit. */
9310 else if (FRAME_X_WINDOW (f
))
9311 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9313 free_frame_menubar (f
);
9314 #else /* !USE_X_TOOLKIT */
9317 /* In the GTK version, tooltips are normal X
9318 frames. We must check and free both types. */
9319 if (FRAME_GTK_OUTER_WIDGET (f
))
9321 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
9322 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow below */
9323 FRAME_GTK_OUTER_WIDGET (f
) = 0;
9325 #endif /* USE_GTK */
9327 if (FRAME_X_WINDOW (f
))
9328 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9329 #endif /* !USE_X_TOOLKIT */
9331 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
9332 unload_color (f
, f
->output_data
.x
->background_pixel
);
9333 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9334 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9335 unload_color (f
, f
->output_data
.x
->border_pixel
);
9336 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9338 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9339 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9340 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9341 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9342 #ifdef USE_TOOLKIT_SCROLL_BARS
9343 /* Scrollbar shadow colors. */
9344 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9345 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9346 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9347 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9348 #endif /* USE_TOOLKIT_SCROLL_BARS */
9349 if (f
->output_data
.x
->white_relief
.allocated_p
)
9350 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9351 if (f
->output_data
.x
->black_relief
.allocated_p
)
9352 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9354 if (FRAME_FACE_CACHE (f
))
9355 free_frame_faces (f
);
9358 XFlush (FRAME_X_DISPLAY (f
));
9361 if (f
->output_data
.x
->saved_menu_event
)
9362 xfree (f
->output_data
.x
->saved_menu_event
);
9364 xfree (f
->output_data
.x
);
9365 f
->output_data
.x
= NULL
;
9367 if (f
== dpyinfo
->x_focus_frame
)
9368 dpyinfo
->x_focus_frame
= 0;
9369 if (f
== dpyinfo
->x_focus_event_frame
)
9370 dpyinfo
->x_focus_event_frame
= 0;
9371 if (f
== dpyinfo
->x_highlight_frame
)
9372 dpyinfo
->x_highlight_frame
= 0;
9374 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9376 dpyinfo
->mouse_face_beg_row
9377 = dpyinfo
->mouse_face_beg_col
= -1;
9378 dpyinfo
->mouse_face_end_row
9379 = dpyinfo
->mouse_face_end_col
= -1;
9380 dpyinfo
->mouse_face_window
= Qnil
;
9381 dpyinfo
->mouse_face_deferred_gc
= 0;
9382 dpyinfo
->mouse_face_mouse_frame
= 0;
9389 /* Destroy the X window of frame F. */
9392 x_destroy_window (f
)
9395 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9397 /* If a display connection is dead, don't try sending more
9398 commands to the X server. */
9399 if (dpyinfo
->display
!= 0)
9400 x_free_frame_resources (f
);
9402 dpyinfo
->reference_count
--;
9406 /* Setting window manager hints. */
9408 /* Set the normal size hints for the window manager, for frame F.
9409 FLAGS is the flags word to use--or 0 meaning preserve the flags
9410 that the window now has.
9411 If USER_POSITION is nonzero, we set the USPosition
9412 flag (this is useful when FLAGS is 0).
9413 The GTK version is in gtkutils.c */
9417 x_wm_set_size_hint (f
, flags
, user_position
)
9422 XSizeHints size_hints
;
9424 #ifdef USE_X_TOOLKIT
9427 Dimension widget_width
, widget_height
;
9430 Window window
= FRAME_OUTER_WINDOW (f
);
9432 /* Setting PMaxSize caused various problems. */
9433 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9435 size_hints
.x
= f
->left_pos
;
9436 size_hints
.y
= f
->top_pos
;
9438 #ifdef USE_X_TOOLKIT
9439 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
9440 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
9441 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
9442 size_hints
.height
= widget_height
;
9443 size_hints
.width
= widget_width
;
9444 #else /* not USE_X_TOOLKIT */
9445 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9446 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9447 #endif /* not USE_X_TOOLKIT */
9449 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9450 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9451 size_hints
.max_width
9452 = FRAME_X_DISPLAY_INFO (f
)->width
- FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9453 size_hints
.max_height
9454 = FRAME_X_DISPLAY_INFO (f
)->height
- FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9456 /* Calculate the base and minimum sizes.
9458 (When we use the X toolkit, we don't do it here.
9459 Instead we copy the values that the widgets are using, below.) */
9460 #ifndef USE_X_TOOLKIT
9462 int base_width
, base_height
;
9463 int min_rows
= 0, min_cols
= 0;
9465 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9466 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9468 check_frame_size (f
, &min_rows
, &min_cols
);
9470 /* The window manager uses the base width hints to calculate the
9471 current number of rows and columns in the frame while
9472 resizing; min_width and min_height aren't useful for this
9473 purpose, since they might not give the dimensions for a
9474 zero-row, zero-column frame.
9476 We use the base_width and base_height members if we have
9477 them; otherwise, we set the min_width and min_height members
9478 to the size for a zero x zero frame. */
9481 size_hints
.flags
|= PBaseSize
;
9482 size_hints
.base_width
= base_width
;
9483 size_hints
.base_height
= base_height
;
9484 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9485 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9487 size_hints
.min_width
= base_width
;
9488 size_hints
.min_height
= base_height
;
9492 /* If we don't need the old flags, we don't need the old hint at all. */
9495 size_hints
.flags
|= flags
;
9498 #endif /* not USE_X_TOOLKIT */
9501 XSizeHints hints
; /* Sometimes I hate X Windows... */
9502 long supplied_return
;
9506 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9509 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
9512 #ifdef USE_X_TOOLKIT
9513 size_hints
.base_height
= hints
.base_height
;
9514 size_hints
.base_width
= hints
.base_width
;
9515 size_hints
.min_height
= hints
.min_height
;
9516 size_hints
.min_width
= hints
.min_width
;
9520 size_hints
.flags
|= flags
;
9525 if (hints
.flags
& PSize
)
9526 size_hints
.flags
|= PSize
;
9527 if (hints
.flags
& PPosition
)
9528 size_hints
.flags
|= PPosition
;
9529 if (hints
.flags
& USPosition
)
9530 size_hints
.flags
|= USPosition
;
9531 if (hints
.flags
& USSize
)
9532 size_hints
.flags
|= USSize
;
9536 #ifndef USE_X_TOOLKIT
9541 size_hints
.win_gravity
= f
->win_gravity
;
9542 size_hints
.flags
|= PWinGravity
;
9546 size_hints
.flags
&= ~ PPosition
;
9547 size_hints
.flags
|= USPosition
;
9549 #endif /* PWinGravity */
9552 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9554 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9557 #endif /* not USE_GTK */
9559 /* Used for IconicState or NormalState */
9562 x_wm_set_window_state (f
, state
)
9566 #ifdef USE_X_TOOLKIT
9569 XtSetArg (al
[0], XtNinitialState
, state
);
9570 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9571 #else /* not USE_X_TOOLKIT */
9572 Window window
= FRAME_X_WINDOW (f
);
9574 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9575 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9577 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9578 #endif /* not USE_X_TOOLKIT */
9582 x_wm_set_icon_pixmap (f
, pixmap_id
)
9586 Pixmap icon_pixmap
, icon_mask
;
9588 #ifndef USE_X_TOOLKIT
9589 Window window
= FRAME_OUTER_WINDOW (f
);
9594 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9595 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9596 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9597 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9601 /* It seems there is no way to turn off use of an icon pixmap.
9602 The following line does it, only if no icon has yet been created,
9603 for some window managers. But with mwm it crashes.
9604 Some people say it should clear the IconPixmapHint bit in this case,
9605 but that doesn't work, and the X consortium said it isn't the
9606 right thing at all. Since there is no way to win,
9607 best to explicitly give up. */
9609 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
9610 f
->output_data
.x
->wm_hints
.icon_mask
= None
;
9619 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9623 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9627 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9628 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9629 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9630 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9633 #else /* not USE_X_TOOLKIT && not USE_GTK */
9635 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9636 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9638 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9642 x_wm_set_icon_position (f
, icon_x
, icon_y
)
9646 Window window
= FRAME_OUTER_WINDOW (f
);
9648 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9649 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9650 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9652 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9656 /***********************************************************************
9658 ***********************************************************************/
9660 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
9663 x_get_font_info (f
, font_idx
)
9667 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
9671 /* Return a list of names of available fonts matching PATTERN on frame F.
9673 If SIZE is > 0, it is the size (maximum bounds width) of fonts
9676 SIZE < 0 means include scalable fonts.
9678 Frame F null means we have not yet created any frame on X, and
9679 consult the first display in x_display_list. MAXNAMES sets a limit
9680 on how many fonts to match. */
9683 x_list_fonts (f
, pattern
, size
, maxnames
)
9685 Lisp_Object pattern
;
9689 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
9690 Lisp_Object tem
, second_best
;
9691 struct x_display_info
*dpyinfo
9692 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
9693 Display
*dpy
= dpyinfo
->display
;
9694 int try_XLoadQueryFont
= 0;
9695 int allow_auto_scaled_font
= 0;
9699 allow_auto_scaled_font
= 1;
9703 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
9704 if (NILP (patterns
))
9705 patterns
= Fcons (pattern
, Qnil
);
9707 if (maxnames
== 1 && !size
)
9708 /* We can return any single font matching PATTERN. */
9709 try_XLoadQueryFont
= 1;
9711 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
9714 char **names
= NULL
;
9716 pattern
= XCAR (patterns
);
9717 /* See if we cached the result for this particular query.
9718 The cache is an alist of the form:
9719 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
9720 tem
= XCDR (dpyinfo
->name_list_element
);
9721 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
9722 allow_auto_scaled_font
? Qt
: Qnil
);
9723 list
= Fassoc (key
, tem
);
9726 list
= Fcdr_safe (list
);
9727 /* We have a cashed list. Don't have to get the list again. */
9731 /* At first, put PATTERN in the cache. */
9734 x_catch_errors (dpy
);
9736 if (try_XLoadQueryFont
)
9739 unsigned long value
;
9741 font
= XLoadQueryFont (dpy
, SDATA (pattern
));
9742 if (x_had_errors_p (dpy
))
9744 /* This error is perhaps due to insufficient memory on X
9745 server. Let's just ignore it. */
9747 x_clear_errors (dpy
);
9751 && XGetFontProperty (font
, XA_FONT
, &value
))
9753 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
9754 int len
= strlen (name
);
9757 /* If DXPC (a Differential X Protocol Compressor)
9758 Ver.3.7 is running, XGetAtomName will return null
9759 string. We must avoid such a name. */
9761 try_XLoadQueryFont
= 0;
9765 names
= (char **) alloca (sizeof (char *));
9766 /* Some systems only allow alloca assigned to a
9768 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
9769 bcopy (name
, names
[0], len
+ 1);
9774 try_XLoadQueryFont
= 0;
9777 XFreeFont (dpy
, font
);
9780 if (!try_XLoadQueryFont
)
9782 /* We try at least 10 fonts because XListFonts will return
9783 auto-scaled fonts at the head. */
9790 names
= XListFonts (dpy
, SDATA (pattern
), limit
, &num_fonts
);
9791 if (num_fonts
== limit
)
9794 XFreeFontNames (names
);
9803 names
= XListFonts (dpy
, SDATA (pattern
), max (maxnames
, 10),
9806 if (x_had_errors_p (dpy
))
9808 /* This error is perhaps due to insufficient memory on X
9809 server. Let's just ignore it. */
9811 x_clear_errors (dpy
);
9815 x_uncatch_errors ();
9822 /* Make a list of all the fonts we got back.
9823 Store that in the font cache for the display. */
9824 for (i
= 0; i
< num_fonts
; i
++)
9828 int average_width
= -1, resx
= 0, dashes
= 0;
9830 /* Count the number of dashes in NAMES[I]. If there are
9831 14 dashes, the field value following 9th dash
9832 (RESOLUTION_X) is nonzero, and the field value
9833 following 12th dash (AVERAGE_WIDTH) is 0, this is a
9834 auto-scaled font which is usually too ugly to be used
9835 for editing. Let's ignore it. */
9840 if (dashes
== 7) /* PIXEL_SIZE field */
9842 else if (dashes
== 9)
9844 else if (dashes
== 12) /* AVERAGE_WIDTH field */
9845 average_width
= atoi (p
);
9848 if (allow_auto_scaled_font
9849 || dashes
< 14 || average_width
!= 0 || resx
== 0)
9851 tem
= build_string (names
[i
]);
9852 if (NILP (Fassoc (tem
, list
)))
9854 if (STRINGP (Vx_pixel_size_width_font_regexp
)
9855 && ((fast_c_string_match_ignore_case
9856 (Vx_pixel_size_width_font_regexp
, names
[i
]))
9858 /* We can set the value of PIXEL_SIZE to the
9859 width of this font. */
9860 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
9862 /* For the moment, width is not known. */
9863 list
= Fcons (Fcons (tem
, Qnil
), list
);
9868 if (!try_XLoadQueryFont
)
9871 XFreeFontNames (names
);
9876 /* Now store the result in the cache. */
9877 XSETCDR (dpyinfo
->name_list_element
,
9878 Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
)));
9881 if (NILP (list
)) continue; /* Try the remaining alternatives. */
9883 newlist
= second_best
= Qnil
;
9884 /* Make a list of the fonts that have the right width. */
9885 for (; CONSP (list
); list
= XCDR (list
))
9891 if (!CONSP (tem
) || NILP (XCAR (tem
)))
9895 newlist
= Fcons (XCAR (tem
), newlist
);
9899 if (!INTEGERP (XCDR (tem
)))
9901 /* Since we have not yet known the size of this font, we
9902 must try slow function call XLoadQueryFont. */
9903 XFontStruct
*thisinfo
;
9906 x_catch_errors (dpy
);
9907 thisinfo
= XLoadQueryFont (dpy
,
9908 SDATA (XCAR (tem
)));
9909 if (x_had_errors_p (dpy
))
9911 /* This error is perhaps due to insufficient memory on X
9912 server. Let's just ignore it. */
9914 x_clear_errors (dpy
);
9916 x_uncatch_errors ();
9922 (thisinfo
->min_bounds
.width
== 0
9924 : make_number (thisinfo
->max_bounds
.width
)));
9926 XFreeFont (dpy
, thisinfo
);
9930 /* For unknown reason, the previous call of XListFont had
9931 returned a font which can't be opened. Record the size
9932 as 0 not to try to open it again. */
9933 XSETCDR (tem
, make_number (0));
9936 found_size
= XINT (XCDR (tem
));
9937 if (found_size
== size
)
9938 newlist
= Fcons (XCAR (tem
), newlist
);
9939 else if (found_size
> 0)
9941 if (NILP (second_best
))
9943 else if (found_size
< size
)
9945 if (XINT (XCDR (second_best
)) > size
9946 || XINT (XCDR (second_best
)) < found_size
)
9951 if (XINT (XCDR (second_best
)) > size
9952 && XINT (XCDR (second_best
)) > found_size
)
9957 if (!NILP (newlist
))
9959 else if (!NILP (second_best
))
9961 newlist
= Fcons (XCAR (second_best
), Qnil
);
9972 /* Check that FONT is valid on frame F. It is if it can be found in F's
9976 x_check_font (f
, font
)
9981 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9983 xassert (font
!= NULL
);
9985 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9986 if (dpyinfo
->font_table
[i
].name
9987 && font
== dpyinfo
->font_table
[i
].font
)
9990 xassert (i
< dpyinfo
->n_fonts
);
9993 #endif /* GLYPH_DEBUG != 0 */
9995 /* Set *W to the minimum width, *H to the minimum font height of FONT.
9996 Note: There are (broken) X fonts out there with invalid XFontStruct
9997 min_bounds contents. For example, handa@etl.go.jp reports that
9998 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
9999 have font->min_bounds.width == 0. */
10002 x_font_min_bounds (font
, w
, h
)
10006 *h
= FONT_HEIGHT (font
);
10007 *w
= font
->min_bounds
.width
;
10009 /* Try to handle the case where FONT->min_bounds has invalid
10010 contents. Since the only font known to have invalid min_bounds
10011 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
10013 *w
= font
->max_bounds
.width
;
10017 /* Compute the smallest character width and smallest font height over
10018 all fonts available on frame F. Set the members smallest_char_width
10019 and smallest_font_height in F's x_display_info structure to
10020 the values computed. Value is non-zero if smallest_font_height or
10021 smallest_char_width become smaller than they were before. */
10024 x_compute_min_glyph_bounds (f
)
10028 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10030 int old_width
= dpyinfo
->smallest_char_width
;
10031 int old_height
= dpyinfo
->smallest_font_height
;
10033 dpyinfo
->smallest_font_height
= 100000;
10034 dpyinfo
->smallest_char_width
= 100000;
10036 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
10037 if (dpyinfo
->font_table
[i
].name
)
10039 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
10042 font
= (XFontStruct
*) fontp
->font
;
10043 xassert (font
!= (XFontStruct
*) ~0);
10044 x_font_min_bounds (font
, &w
, &h
);
10046 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
10047 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
10050 xassert (dpyinfo
->smallest_char_width
> 0
10051 && dpyinfo
->smallest_font_height
> 0);
10053 return (dpyinfo
->n_fonts
== 1
10054 || dpyinfo
->smallest_char_width
< old_width
10055 || dpyinfo
->smallest_font_height
< old_height
);
10059 /* Load font named FONTNAME of the size SIZE for frame F, and return a
10060 pointer to the structure font_info while allocating it dynamically.
10061 If SIZE is 0, load any size of font.
10062 If loading is failed, return NULL. */
10065 x_load_font (f
, fontname
, size
)
10067 register char *fontname
;
10070 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10071 Lisp_Object font_names
;
10073 /* Get a list of all the fonts that match this name. Once we
10074 have a list of matching fonts, we compare them against the fonts
10075 we already have by comparing names. */
10076 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
10078 if (!NILP (font_names
))
10083 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10084 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
10085 if (dpyinfo
->font_table
[i
].name
10086 && (!strcmp (dpyinfo
->font_table
[i
].name
,
10087 SDATA (XCAR (tail
)))
10088 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
10089 SDATA (XCAR (tail
)))))
10090 return (dpyinfo
->font_table
+ i
);
10093 /* Load the font and add it to the table. */
10097 struct font_info
*fontp
;
10098 unsigned long value
;
10101 /* If we have found fonts by x_list_font, load one of them. If
10102 not, we still try to load a font by the name given as FONTNAME
10103 because XListFonts (called in x_list_font) of some X server has
10104 a bug of not finding a font even if the font surely exists and
10105 is loadable by XLoadQueryFont. */
10106 if (size
> 0 && !NILP (font_names
))
10107 fontname
= (char *) SDATA (XCAR (font_names
));
10110 x_catch_errors (FRAME_X_DISPLAY (f
));
10111 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
10112 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
10114 /* This error is perhaps due to insufficient memory on X
10115 server. Let's just ignore it. */
10117 x_clear_errors (FRAME_X_DISPLAY (f
));
10119 x_uncatch_errors ();
10124 /* Find a free slot in the font table. */
10125 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
10126 if (dpyinfo
->font_table
[i
].name
== NULL
)
10129 /* If no free slot found, maybe enlarge the font table. */
10130 if (i
== dpyinfo
->n_fonts
10131 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
10134 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
10135 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
10136 dpyinfo
->font_table
10137 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
10140 fontp
= dpyinfo
->font_table
+ i
;
10141 if (i
== dpyinfo
->n_fonts
)
10142 ++dpyinfo
->n_fonts
;
10144 /* Now fill in the slots of *FONTP. */
10146 bzero (fontp
, sizeof (*fontp
));
10147 fontp
->font
= font
;
10148 fontp
->font_idx
= i
;
10149 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
10150 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
10152 if (font
->min_bounds
.width
== font
->max_bounds
.width
)
10154 /* Fixed width font. */
10155 fontp
->average_width
= fontp
->space_width
= font
->min_bounds
.width
;
10162 char2b
.byte1
= 0x00, char2b
.byte2
= 0x20;
10163 pcm
= x_per_char_metric (font
, &char2b
, 0);
10165 fontp
->space_width
= pcm
->width
;
10167 fontp
->space_width
= FONT_WIDTH (font
);
10169 fontp
->average_width
10170 = (XGetFontProperty (font
, dpyinfo
->Xatom_AVERAGE_WIDTH
, &value
)
10171 ? (long) value
/ 10 : 0);
10172 if (fontp
->average_width
< 0)
10173 fontp
->average_width
= - fontp
->average_width
;
10174 if (fontp
->average_width
== 0)
10178 int width
= pcm
->width
;
10179 for (char2b
.byte2
= 33; char2b
.byte2
<= 126; char2b
.byte2
++)
10180 if ((pcm
= x_per_char_metric (font
, &char2b
, 0)) != NULL
)
10181 width
+= pcm
->width
;
10182 fontp
->average_width
= width
/ 95;
10185 fontp
->average_width
= FONT_WIDTH (font
);
10189 /* Try to get the full name of FONT. Put it in FULL_NAME. */
10191 if (XGetFontProperty (font
, XA_FONT
, &value
))
10193 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
10197 /* Count the number of dashes in the "full name".
10198 If it is too few, this isn't really the font's full name,
10200 In X11R4, the fonts did not come with their canonical names
10211 full_name
= (char *) xmalloc (p
- name
+ 1);
10212 bcopy (name
, full_name
, p
- name
+ 1);
10218 if (full_name
!= 0)
10219 fontp
->full_name
= full_name
;
10221 fontp
->full_name
= fontp
->name
;
10223 fontp
->size
= font
->max_bounds
.width
;
10224 fontp
->height
= FONT_HEIGHT (font
);
10226 if (NILP (font_names
))
10228 /* We come here because of a bug of XListFonts mentioned at
10229 the head of this block. Let's store this information in
10230 the cache for x_list_fonts. */
10231 Lisp_Object lispy_name
= build_string (fontname
);
10232 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
10233 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
10236 XSETCDR (dpyinfo
->name_list_element
,
10238 Fcons (Fcons (lispy_full_name
,
10239 make_number (fontp
->size
)),
10241 XCDR (dpyinfo
->name_list_element
)));
10244 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
10246 XSETCDR (dpyinfo
->name_list_element
,
10248 Fcons (Fcons (lispy_full_name
,
10249 make_number (fontp
->size
)),
10251 XCDR (dpyinfo
->name_list_element
)));
10255 /* The slot `encoding' specifies how to map a character
10256 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
10257 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
10258 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
10259 2:0xA020..0xFF7F). For the moment, we don't know which charset
10260 uses this font. So, we set information in fontp->encoding[1]
10261 which is never used by any charset. If mapping can't be
10262 decided, set FONT_ENCODING_NOT_DECIDED. */
10264 = (font
->max_byte1
== 0
10266 ? (font
->min_char_or_byte2
< 0x80
10267 ? (font
->max_char_or_byte2
< 0x80
10268 ? 0 /* 0x20..0x7F */
10269 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
10270 : 1) /* 0xA0..0xFF */
10272 : (font
->min_byte1
< 0x80
10273 ? (font
->max_byte1
< 0x80
10274 ? (font
->min_char_or_byte2
< 0x80
10275 ? (font
->max_char_or_byte2
< 0x80
10276 ? 0 /* 0x2020..0x7F7F */
10277 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
10278 : 3) /* 0x20A0..0x7FFF */
10279 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
10280 : (font
->min_char_or_byte2
< 0x80
10281 ? (font
->max_char_or_byte2
< 0x80
10282 ? 2 /* 0xA020..0xFF7F */
10283 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
10284 : 1))); /* 0xA0A0..0xFFFF */
10286 fontp
->baseline_offset
10287 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
10288 ? (long) value
: 0);
10289 fontp
->relative_compose
10290 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
10291 ? (long) value
: 0);
10292 fontp
->default_ascent
10293 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
10294 ? (long) value
: 0);
10296 /* Set global flag fonts_changed_p to non-zero if the font loaded
10297 has a character with a smaller width than any other character
10298 before, or if the font loaded has a smaller height than any
10299 other font loaded before. If this happens, it will make a
10300 glyph matrix reallocation necessary. */
10301 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
10308 /* Return a pointer to struct font_info of a font named FONTNAME for
10309 frame F. If no such font is loaded, return NULL. */
10312 x_query_font (f
, fontname
)
10314 register char *fontname
;
10316 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10319 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10320 if (dpyinfo
->font_table
[i
].name
10321 && (!xstricmp (dpyinfo
->font_table
[i
].name
, fontname
)
10322 || !xstricmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
10323 return (dpyinfo
->font_table
+ i
);
10328 /* Find a CCL program for a font specified by FONTP, and set the member
10329 `encoder' of the structure. */
10332 x_find_ccl_program (fontp
)
10333 struct font_info
*fontp
;
10335 Lisp_Object list
, elt
;
10338 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
10342 && STRINGP (XCAR (elt
))
10343 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
10345 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
10352 struct ccl_program
*ccl
10353 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
10355 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
10358 fontp
->font_encoder
= ccl
;
10364 /***********************************************************************
10366 ***********************************************************************/
10368 #ifdef USE_X_TOOLKIT
10369 static XrmOptionDescRec emacs_options
[] = {
10370 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
10371 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
10373 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10374 XrmoptionSepArg
, NULL
},
10375 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
10377 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10378 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10379 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10380 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10381 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10382 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
10383 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
10386 /* Whether atimer for Xt timeouts is activated or not. */
10388 static int x_timeout_atimer_activated_flag
;
10390 #endif /* USE_X_TOOLKIT */
10392 static int x_initialized
;
10395 static int x_session_initialized
;
10398 #ifdef MULTI_KBOARD
10399 /* Test whether two display-name strings agree up to the dot that separates
10400 the screen number from the server number. */
10402 same_x_server (name1
, name2
)
10403 const char *name1
, *name2
;
10405 int seen_colon
= 0;
10406 const unsigned char *system_name
= SDATA (Vsystem_name
);
10407 int system_name_length
= strlen (system_name
);
10408 int length_until_period
= 0;
10410 while (system_name
[length_until_period
] != 0
10411 && system_name
[length_until_period
] != '.')
10412 length_until_period
++;
10414 /* Treat `unix' like an empty host name. */
10415 if (! strncmp (name1
, "unix:", 5))
10417 if (! strncmp (name2
, "unix:", 5))
10419 /* Treat this host's name like an empty host name. */
10420 if (! strncmp (name1
, system_name
, system_name_length
)
10421 && name1
[system_name_length
] == ':')
10422 name1
+= system_name_length
;
10423 if (! strncmp (name2
, system_name
, system_name_length
)
10424 && name2
[system_name_length
] == ':')
10425 name2
+= system_name_length
;
10426 /* Treat this host's domainless name like an empty host name. */
10427 if (! strncmp (name1
, system_name
, length_until_period
)
10428 && name1
[length_until_period
] == ':')
10429 name1
+= length_until_period
;
10430 if (! strncmp (name2
, system_name
, length_until_period
)
10431 && name2
[length_until_period
] == ':')
10432 name2
+= length_until_period
;
10434 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
10438 if (seen_colon
&& *name1
== '.')
10442 && (*name1
== '.' || *name1
== '\0')
10443 && (*name2
== '.' || *name2
== '\0'));
10447 /* Count number of set bits in mask and number of bits to shift to
10448 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
10451 get_bits_and_offset (mask
, bits
, offset
)
10452 unsigned long mask
;
10459 while (!(mask
& 1))
10476 x_display_ok (display
)
10477 const char * display
;
10482 dpy
= XOpenDisplay (display
);
10484 XCloseDisplay (dpy
);
10490 struct x_display_info
*
10491 x_term_init (display_name
, xrm_option
, resource_name
)
10492 Lisp_Object display_name
;
10494 char *resource_name
;
10498 struct x_display_info
*dpyinfo
;
10503 if (!x_initialized
)
10511 #define NUM_ARGV 10
10513 char *argv
[NUM_ARGV
];
10514 char **argv2
= argv
;
10517 if (x_initialized
++ > 1)
10519 /* Opening another display. If xg_display_open returns less
10520 than zero, we are probably on GTK 2.0, which can only handle
10521 one display. GTK 2.2 or later can handle more than one. */
10522 if (xg_display_open (SDATA (display_name
), &dpy
) < 0)
10523 error ("Sorry, this version of GTK can only handle one display");
10527 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
10531 argv
[argc
++] = initial_argv
[0];
10533 if (! NILP (display_name
))
10535 argv
[argc
++] = "--display";
10536 argv
[argc
++] = SDATA (display_name
);
10539 argv
[argc
++] = "--name";
10540 argv
[argc
++] = resource_name
;
10543 XSetLocaleModifiers ("");
10546 gtk_init (&argc
, &argv2
);
10548 /* gtk_init does set_locale. We must fix locale after calling it. */
10552 dpy
= GDK_DISPLAY ();
10554 /* NULL window -> events for all windows go to our function */
10555 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
10557 /* Load our own gtkrc if it exists. */
10559 char *file
= "~/.emacs.d/gtkrc";
10560 Lisp_Object s
, abs_file
;
10562 s
= make_string (file
, strlen (file
));
10563 abs_file
= Fexpand_file_name (s
, Qnil
);
10565 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
10566 gtk_rc_parse (SDATA (abs_file
));
10569 XSetErrorHandler (x_error_handler
);
10570 XSetIOErrorHandler (x_io_error_quitter
);
10573 #else /* not USE_GTK */
10574 #ifdef USE_X_TOOLKIT
10575 /* weiner@footloose.sps.mot.com reports that this causes
10577 X protocol error: BadAtom (invalid Atom parameter)
10578 on protocol request 18skiloaf.
10579 So let's not use it until R6. */
10580 #ifdef HAVE_X11XTR6
10581 XtSetLanguageProc (NULL
, NULL
, NULL
);
10592 argv
[argc
++] = "-xrm";
10593 argv
[argc
++] = xrm_option
;
10595 turn_on_atimers (0);
10596 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
10597 resource_name
, EMACS_CLASS
,
10598 emacs_options
, XtNumber (emacs_options
),
10600 turn_on_atimers (1);
10602 #ifdef HAVE_X11XTR6
10603 /* I think this is to compensate for XtSetLanguageProc. */
10608 #else /* not USE_X_TOOLKIT */
10610 XSetLocaleModifiers ("");
10612 dpy
= XOpenDisplay (SDATA (display_name
));
10613 #endif /* not USE_X_TOOLKIT */
10614 #endif /* not USE_GTK*/
10616 /* Detect failure. */
10623 /* We have definitely succeeded. Record the new connection. */
10625 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
10626 bzero (dpyinfo
, sizeof *dpyinfo
);
10628 #ifdef MULTI_KBOARD
10630 struct x_display_info
*share
;
10633 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
10634 share
= share
->next
, tail
= XCDR (tail
))
10635 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
10636 SDATA (display_name
)))
10639 dpyinfo
->kboard
= share
->kboard
;
10642 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
10643 init_kboard (dpyinfo
->kboard
);
10644 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
10646 char *vendor
= ServerVendor (dpy
);
10648 dpyinfo
->kboard
->Vsystem_key_alist
10649 = call1 (Qvendor_specific_keysyms
,
10650 build_string (vendor
? vendor
: ""));
10654 dpyinfo
->kboard
->next_kboard
= all_kboards
;
10655 all_kboards
= dpyinfo
->kboard
;
10656 /* Don't let the initial kboard remain current longer than necessary.
10657 That would cause problems if a file loaded on startup tries to
10658 prompt in the mini-buffer. */
10659 if (current_kboard
== initial_kboard
)
10660 current_kboard
= dpyinfo
->kboard
;
10662 dpyinfo
->kboard
->reference_count
++;
10666 /* Put this display on the chain. */
10667 dpyinfo
->next
= x_display_list
;
10668 x_display_list
= dpyinfo
;
10670 /* Put it on x_display_name_list as well, to keep them parallel. */
10671 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
10672 x_display_name_list
);
10673 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
10675 dpyinfo
->display
= dpy
;
10678 XSetAfterFunction (x_current_display
, x_trace_wire
);
10682 = (char *) xmalloc (SBYTES (Vinvocation_name
)
10683 + SBYTES (Vsystem_name
)
10685 sprintf (dpyinfo
->x_id_name
, "%s@%s",
10686 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10688 /* Figure out which modifier bits mean what. */
10689 x_find_modifier_meanings (dpyinfo
);
10691 /* Get the scroll bar cursor. */
10693 /* We must create a GTK cursor, it is required for GTK widgets. */
10694 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10695 #endif /* USE_GTK */
10697 dpyinfo
->vertical_scroll_bar_cursor
10698 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10700 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10701 resource_name
, EMACS_CLASS
);
10702 #ifdef HAVE_XRMSETDATABASE
10703 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10705 dpyinfo
->display
->db
= xrdb
;
10707 /* Put the rdb where we can find it in a way that works on
10709 dpyinfo
->xrdb
= xrdb
;
10711 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10712 DefaultScreen (dpyinfo
->display
));
10713 select_visual (dpyinfo
);
10714 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10715 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
10716 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
10717 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10718 dpyinfo
->client_leader_window
= 0;
10719 dpyinfo
->grabbed
= 0;
10720 dpyinfo
->reference_count
= 0;
10721 dpyinfo
->icon_bitmap_id
= -1;
10722 dpyinfo
->font_table
= NULL
;
10723 dpyinfo
->n_fonts
= 0;
10724 dpyinfo
->font_table_size
= 0;
10725 dpyinfo
->bitmaps
= 0;
10726 dpyinfo
->bitmaps_size
= 0;
10727 dpyinfo
->bitmaps_last
= 0;
10728 dpyinfo
->scratch_cursor_gc
= 0;
10729 dpyinfo
->mouse_face_mouse_frame
= 0;
10730 dpyinfo
->mouse_face_deferred_gc
= 0;
10731 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10732 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10733 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10734 dpyinfo
->mouse_face_window
= Qnil
;
10735 dpyinfo
->mouse_face_overlay
= Qnil
;
10736 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10737 dpyinfo
->mouse_face_defer
= 0;
10738 dpyinfo
->mouse_face_hidden
= 0;
10739 dpyinfo
->x_focus_frame
= 0;
10740 dpyinfo
->x_focus_event_frame
= 0;
10741 dpyinfo
->x_highlight_frame
= 0;
10742 dpyinfo
->image_cache
= make_image_cache ();
10743 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10745 /* See if we can construct pixel values from RGB values. */
10746 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10747 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10749 if (dpyinfo
->visual
->class == TrueColor
)
10751 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10752 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10753 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10754 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10755 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10756 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10759 /* See if a private colormap is requested. */
10760 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10762 if (dpyinfo
->visual
->class == PseudoColor
)
10765 value
= display_x_get_resource (dpyinfo
,
10766 build_string ("privateColormap"),
10767 build_string ("PrivateColormap"),
10769 if (STRINGP (value
)
10770 && (!strcmp (SDATA (value
), "true")
10771 || !strcmp (SDATA (value
), "on")))
10772 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10776 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10777 dpyinfo
->visual
, AllocNone
);
10780 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10781 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10782 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10783 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10784 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10785 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10786 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10787 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10788 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10791 dpyinfo
->Xatom_wm_protocols
10792 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10793 dpyinfo
->Xatom_wm_take_focus
10794 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10795 dpyinfo
->Xatom_wm_save_yourself
10796 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10797 dpyinfo
->Xatom_wm_delete_window
10798 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10799 dpyinfo
->Xatom_wm_change_state
10800 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10801 dpyinfo
->Xatom_wm_configure_denied
10802 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10803 dpyinfo
->Xatom_wm_window_moved
10804 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10805 dpyinfo
->Xatom_wm_client_leader
10806 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10807 dpyinfo
->Xatom_editres
10808 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10809 dpyinfo
->Xatom_CLIPBOARD
10810 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10811 dpyinfo
->Xatom_TIMESTAMP
10812 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10813 dpyinfo
->Xatom_TEXT
10814 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10815 dpyinfo
->Xatom_COMPOUND_TEXT
10816 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10817 dpyinfo
->Xatom_UTF8_STRING
10818 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10819 dpyinfo
->Xatom_DELETE
10820 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10821 dpyinfo
->Xatom_MULTIPLE
10822 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10823 dpyinfo
->Xatom_INCR
10824 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10825 dpyinfo
->Xatom_EMACS_TMP
10826 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10827 dpyinfo
->Xatom_TARGETS
10828 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10829 dpyinfo
->Xatom_NULL
10830 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10831 dpyinfo
->Xatom_ATOM_PAIR
10832 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10833 /* For properties of font. */
10834 dpyinfo
->Xatom_PIXEL_SIZE
10835 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10836 dpyinfo
->Xatom_AVERAGE_WIDTH
10837 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10838 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10839 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10840 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10841 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10842 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10843 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10845 /* Ghostscript support. */
10846 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10847 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10849 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10852 dpyinfo
->cut_buffers_initialized
= 0;
10854 dpyinfo
->x_dnd_atoms_size
= 8;
10855 dpyinfo
->x_dnd_atoms_length
= 0;
10856 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10857 * dpyinfo
->x_dnd_atoms_size
);
10859 dpyinfo
->net_supported_atoms
= NULL
;
10860 dpyinfo
->nr_net_supported_atoms
= 0;
10861 dpyinfo
->net_supported_window
= 0;
10863 connection
= ConnectionNumber (dpyinfo
->display
);
10864 dpyinfo
->connection
= connection
;
10869 null_bits
[0] = 0x00;
10871 dpyinfo
->null_pixel
10872 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10873 null_bits
, 1, 1, (long) 0, (long) 0,
10878 extern int gray_bitmap_width
, gray_bitmap_height
;
10879 extern char *gray_bitmap_bits
;
10881 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10883 gray_bitmap_width
, gray_bitmap_height
,
10884 (unsigned long) 1, (unsigned long) 0, 1);
10888 xim_initialize (dpyinfo
, resource_name
);
10891 #ifdef subprocesses
10892 /* This is only needed for distinguishing keyboard and process input. */
10893 if (connection
!= 0)
10894 add_keyboard_wait_descriptor (connection
);
10897 #ifndef F_SETOWN_BUG
10899 #ifdef F_SETOWN_SOCK_NEG
10900 /* stdin is a socket here */
10901 fcntl (connection
, F_SETOWN
, -getpid ());
10902 #else /* ! defined (F_SETOWN_SOCK_NEG) */
10903 fcntl (connection
, F_SETOWN
, getpid ());
10904 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
10905 #endif /* ! defined (F_SETOWN) */
10906 #endif /* F_SETOWN_BUG */
10909 if (interrupt_input
)
10910 init_sigio (connection
);
10911 #endif /* ! defined (SIGIO) */
10914 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
10915 /* Make sure that we have a valid font for dialog boxes
10916 so that Xt does not crash. */
10918 Display
*dpy
= dpyinfo
->display
;
10919 XrmValue d
, fr
, to
;
10922 d
.addr
= (XPointer
)&dpy
;
10923 d
.size
= sizeof (Display
*);
10924 fr
.addr
= XtDefaultFont
;
10925 fr
.size
= sizeof (XtDefaultFont
);
10926 to
.size
= sizeof (Font
*);
10927 to
.addr
= (XPointer
)&font
;
10928 x_catch_errors (dpy
);
10929 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10931 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10932 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10933 x_uncatch_errors ();
10938 /* See if we should run in synchronous mode. This is useful
10939 for debugging X code. */
10942 value
= display_x_get_resource (dpyinfo
,
10943 build_string ("synchronous"),
10944 build_string ("Synchronous"),
10946 if (STRINGP (value
)
10947 && (!strcmp (SDATA (value
), "true")
10948 || !strcmp (SDATA (value
), "on")))
10949 XSynchronize (dpyinfo
->display
, True
);
10954 value
= display_x_get_resource (dpyinfo
,
10955 build_string ("useXIM"),
10956 build_string ("UseXIM"),
10959 if (STRINGP (value
)
10960 && (!strcmp (XSTRING (value
)->data
, "false")
10961 || !strcmp (XSTRING (value
)->data
, "off")))
10964 if (STRINGP (value
)
10965 && (!strcmp (XSTRING (value
)->data
, "true")
10966 || !strcmp (XSTRING (value
)->data
, "on")))
10972 /* Only do this for the first display. */
10973 if (!x_session_initialized
++)
10974 x_session_initialize (dpyinfo
);
10982 /* Get rid of display DPYINFO, assuming all frames are already gone,
10983 and without sending any more commands to the X server. */
10986 x_delete_display (dpyinfo
)
10987 struct x_display_info
*dpyinfo
;
10991 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10993 /* Discard this display from x_display_name_list and x_display_list.
10994 We can't use Fdelq because that can quit. */
10995 if (! NILP (x_display_name_list
)
10996 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10997 x_display_name_list
= XCDR (x_display_name_list
);
11002 tail
= x_display_name_list
;
11003 while (CONSP (tail
) && CONSP (XCDR (tail
)))
11005 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
11007 XSETCDR (tail
, XCDR (XCDR (tail
)));
11010 tail
= XCDR (tail
);
11014 if (next_noop_dpyinfo
== dpyinfo
)
11015 next_noop_dpyinfo
= dpyinfo
->next
;
11017 if (x_display_list
== dpyinfo
)
11018 x_display_list
= dpyinfo
->next
;
11021 struct x_display_info
*tail
;
11023 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
11024 if (tail
->next
== dpyinfo
)
11025 tail
->next
= tail
->next
->next
;
11028 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
11029 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
11030 XrmDestroyDatabase (dpyinfo
->xrdb
);
11033 #ifdef MULTI_KBOARD
11034 if (--dpyinfo
->kboard
->reference_count
== 0)
11035 delete_kboard (dpyinfo
->kboard
);
11039 xim_close_dpy (dpyinfo
);
11042 /* Free the font names in the font table. */
11043 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
11044 if (dpyinfo
->font_table
[i
].name
)
11046 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
11047 xfree (dpyinfo
->font_table
[i
].full_name
);
11048 xfree (dpyinfo
->font_table
[i
].name
);
11051 if (dpyinfo
->font_table
)
11053 if (dpyinfo
->font_table
->font_encoder
)
11054 xfree (dpyinfo
->font_table
->font_encoder
);
11055 xfree (dpyinfo
->font_table
);
11057 if (dpyinfo
->x_id_name
)
11058 xfree (dpyinfo
->x_id_name
);
11059 if (dpyinfo
->color_cells
)
11060 xfree (dpyinfo
->color_cells
);
11064 #ifdef USE_X_TOOLKIT
11066 /* Atimer callback function for TIMER. Called every 0.1s to process
11067 Xt timeouts, if needed. We must avoid calling XtAppPending as
11068 much as possible because that function does an implicit XFlush
11069 that slows us down. */
11072 x_process_timeouts (timer
)
11073 struct atimer
*timer
;
11076 x_timeout_atimer_activated_flag
= 0;
11077 if (toolkit_scroll_bar_interaction
|| popup_activated ())
11079 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
11080 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
11081 /* Reactivate the atimer for next time. */
11082 x_activate_timeout_atimer ();
11087 /* Install an asynchronous timer that processes Xt timeout events
11088 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
11089 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
11090 function whenever these variables are set. This is necessary
11091 because some widget sets use timeouts internally, for example the
11092 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
11093 processed, these widgets don't behave normally. */
11096 x_activate_timeout_atimer ()
11099 if (!x_timeout_atimer_activated_flag
)
11101 EMACS_TIME interval
;
11103 EMACS_SET_SECS_USECS (interval
, 0, 100000);
11104 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
11105 x_timeout_atimer_activated_flag
= 1;
11110 #endif /* USE_X_TOOLKIT */
11113 /* Set up use of X before we make the first connection. */
11115 extern frame_parm_handler x_frame_parm_handlers
[];
11117 static struct redisplay_interface x_redisplay_interface
=
11119 x_frame_parm_handlers
,
11123 x_clear_end_of_line
,
11125 x_after_update_window_line
,
11126 x_update_window_begin
,
11127 x_update_window_end
,
11133 0, /* flush_display_optional */
11135 x_clear_window_mouse_face
,
11136 x_get_glyph_overhangs
,
11137 x_fix_overlapping_area
,
11138 x_draw_fringe_bitmap
,
11139 0, /* define_fringe_bitmap */
11140 0, /* destroy_fringe_bitmap */
11143 x_compute_glyph_string_overhangs
,
11144 x_draw_glyph_string
,
11145 x_define_frame_cursor
,
11146 x_clear_frame_area
,
11147 x_draw_window_cursor
,
11148 x_draw_vertical_window_border
,
11149 x_shift_glyphs_for_insert
11155 rif
= &x_redisplay_interface
;
11157 clear_frame_hook
= x_clear_frame
;
11158 ins_del_lines_hook
= x_ins_del_lines
;
11159 delete_glyphs_hook
= x_delete_glyphs
;
11160 ring_bell_hook
= XTring_bell
;
11161 reset_terminal_modes_hook
= XTreset_terminal_modes
;
11162 set_terminal_modes_hook
= XTset_terminal_modes
;
11163 update_begin_hook
= x_update_begin
;
11164 update_end_hook
= x_update_end
;
11165 set_terminal_window_hook
= XTset_terminal_window
;
11166 read_socket_hook
= XTread_socket
;
11167 frame_up_to_date_hook
= XTframe_up_to_date
;
11168 mouse_position_hook
= XTmouse_position
;
11169 frame_rehighlight_hook
= XTframe_rehighlight
;
11170 frame_raise_lower_hook
= XTframe_raise_lower
;
11171 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
11172 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
11173 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
11174 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
11175 fullscreen_hook
= XTfullscreen_hook
;
11177 scroll_region_ok
= 1; /* we'll scroll partial frames */
11178 char_ins_del_ok
= 1;
11179 line_ins_del_ok
= 1; /* we'll just blt 'em */
11180 fast_clear_end_of_line
= 1; /* X does this well */
11181 memory_below_frame
= 0; /* we don't remember what scrolls
11186 last_tool_bar_item
= -1;
11187 any_help_event_p
= 0;
11188 ignore_next_mouse_click_timeout
= 0;
11190 x_session_initialized
= 0;
11194 current_count
= -1;
11197 /* Try to use interrupt input; if we can't, then start polling. */
11198 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
11200 #ifdef USE_X_TOOLKIT
11201 XtToolkitInitialize ();
11203 Xt_app_con
= XtCreateApplicationContext ();
11205 /* Register a converter from strings to pixels, which uses
11206 Emacs' color allocation infrastructure. */
11207 XtAppSetTypeConverter (Xt_app_con
,
11208 XtRString
, XtRPixel
, cvt_string_to_pixel
,
11209 cvt_string_to_pixel_args
,
11210 XtNumber (cvt_string_to_pixel_args
),
11211 XtCacheByDisplay
, cvt_pixel_dtor
);
11213 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
11216 #ifdef USE_TOOLKIT_SCROLL_BARS
11218 xaw3d_arrow_scroll
= False
;
11219 xaw3d_pick_top
= True
;
11223 /* Note that there is no real way portable across R3/R4 to get the
11224 original error handler. */
11225 XSetErrorHandler (x_error_handler
);
11226 XSetIOErrorHandler (x_io_error_quitter
);
11228 /* Disable Window Change signals; they are handled by X events. */
11230 signal (SIGWINCH
, SIG_DFL
);
11231 #endif /* SIGWINCH */
11233 signal (SIGPIPE
, x_connection_signal
);
11240 x_error_message
= NULL
;
11242 staticpro (&x_display_name_list
);
11243 x_display_name_list
= Qnil
;
11245 staticpro (&last_mouse_scroll_bar
);
11246 last_mouse_scroll_bar
= Qnil
;
11248 staticpro (&Qvendor_specific_keysyms
);
11249 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
11251 staticpro (&Qutf_8
);
11252 Qutf_8
= intern ("utf-8");
11253 staticpro (&Qlatin_1
);
11254 Qlatin_1
= intern ("latin-1");
11256 staticpro (&last_mouse_press_frame
);
11257 last_mouse_press_frame
= Qnil
;
11259 DEFVAR_BOOL ("x-use-underline-position-properties",
11260 &x_use_underline_position_properties
,
11261 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
11262 A value of nil means ignore them. If you encounter fonts with bogus
11263 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
11264 to 4.1, set this to nil. */);
11265 x_use_underline_position_properties
= 1;
11267 DEFVAR_BOOL ("x-underline-at-descent-line",
11268 &x_underline_at_descent_line
,
11269 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
11270 A value of nil means to draw the underline according to the value of the
11271 variable `x-use-underline-position-properties', which is usually at the
11272 baseline level. The default value is nil. */);
11273 x_underline_at_descent_line
= 0;
11275 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
11276 &x_mouse_click_focus_ignore_position
,
11277 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
11278 This variable is only used when the window manager requires that you
11279 click on a frame to select it (give it focus). In that case, a value
11280 of nil, means that the selected window and cursor position changes to
11281 reflect the mouse click position, while a non-nil value means that the
11282 selected window or cursor position is preserved. */);
11283 x_mouse_click_focus_ignore_position
= 0;
11285 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
11286 doc
: /* What X toolkit scroll bars Emacs uses.
11287 A value of nil means Emacs doesn't use X toolkit scroll bars.
11288 Otherwise, value is a symbol describing the X toolkit. */);
11289 #ifdef USE_TOOLKIT_SCROLL_BARS
11291 Vx_toolkit_scroll_bars
= intern ("motif");
11292 #elif defined HAVE_XAW3D
11293 Vx_toolkit_scroll_bars
= intern ("xaw3d");
11295 Vx_toolkit_scroll_bars
= intern ("gtk");
11297 Vx_toolkit_scroll_bars
= intern ("xaw");
11300 Vx_toolkit_scroll_bars
= Qnil
;
11303 staticpro (&last_mouse_motion_frame
);
11304 last_mouse_motion_frame
= Qnil
;
11306 Qmodifier_value
= intern ("modifier-value");
11307 Qalt
= intern ("alt");
11308 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
11309 Qhyper
= intern ("hyper");
11310 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
11311 Qmeta
= intern ("meta");
11312 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
11313 Qsuper
= intern ("super");
11314 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
11316 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
11317 doc
: /* Which keys Emacs uses for the alt modifier.
11318 This should be one of the symbols `alt', `hyper', `meta', `super'.
11319 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
11320 is nil, which is the same as `alt'. */);
11321 Vx_alt_keysym
= Qnil
;
11323 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
11324 doc
: /* Which keys Emacs uses for the hyper modifier.
11325 This should be one of the symbols `alt', `hyper', `meta', `super'.
11326 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
11327 default is nil, which is the same as `hyper'. */);
11328 Vx_hyper_keysym
= Qnil
;
11330 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
11331 doc
: /* Which keys Emacs uses for the meta modifier.
11332 This should be one of the symbols `alt', `hyper', `meta', `super'.
11333 For example, `meta' means use the Meta_L and Meta_R keysyms. The
11334 default is nil, which is the same as `meta'. */);
11335 Vx_meta_keysym
= Qnil
;
11337 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
11338 doc
: /* Which keys Emacs uses for the super modifier.
11339 This should be one of the symbols `alt', `hyper', `meta', `super'.
11340 For example, `super' means use the Super_L and Super_R keysyms. The
11341 default is nil, which is the same as `super'. */);
11342 Vx_super_keysym
= Qnil
;
11344 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
11345 doc
: /* Hash table of character codes indexed by X keysym codes. */);
11346 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
11347 make_float (DEFAULT_REHASH_SIZE
),
11348 make_float (DEFAULT_REHASH_THRESHOLD
),
11352 #endif /* HAVE_X_WINDOWS */
11354 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
11355 (do not change this comment) */