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 if (EQ (window
, f
->tool_bar_window
))
6764 if (event
.xbutton
.type
== ButtonPress
)
6765 handle_tool_bar_click (f
, x
, y
, 1, 0);
6767 handle_tool_bar_click (f
, x
, y
, 0,
6768 x_x_to_emacs_modifiers (dpyinfo
,
6769 event
.xbutton
.state
));
6775 if (!dpyinfo
->x_focus_frame
6776 || f
== dpyinfo
->x_focus_frame
)
6778 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6779 if (! popup_activated ())
6782 if (ignore_next_mouse_click_timeout
)
6784 if (event
.type
== ButtonPress
6785 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6787 ignore_next_mouse_click_timeout
= 0;
6788 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6790 if (event
.type
== ButtonRelease
)
6791 ignore_next_mouse_click_timeout
= 0;
6794 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6800 struct scroll_bar
*bar
6801 = x_window_to_scroll_bar (event
.xbutton
.display
,
6802 event
.xbutton
.window
);
6804 #ifdef USE_TOOLKIT_SCROLL_BARS
6805 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6807 if (bar
&& event
.xbutton
.state
& ControlMask
)
6809 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6810 *finish
= X_EVENT_DROP
;
6812 #else /* not USE_TOOLKIT_SCROLL_BARS */
6814 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6815 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6818 if (event
.type
== ButtonPress
)
6820 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6821 last_mouse_frame
= f
;
6824 last_tool_bar_item
= -1;
6827 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6829 /* Ignore any mouse motion that happened before this event;
6830 any subsequent mouse-movement Emacs events should reflect
6831 only motion after the ButtonPress/Release. */
6835 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6836 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6837 /* For a down-event in the menu bar,
6838 don't pass it to Xt right now.
6839 Instead, save it away
6840 and we will pass it to Xt from kbd_buffer_get_event.
6841 That way, we can run some Lisp code first. */
6844 ! popup_activated ()
6847 f
&& event
.type
== ButtonPress
6848 /* Verify the event is really within the menu bar
6849 and not just sent to it due to grabbing. */
6850 && event
.xbutton
.x
>= 0
6851 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6852 && event
.xbutton
.y
>= 0
6853 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6854 && event
.xbutton
.same_screen
)
6856 SET_SAVED_BUTTON_EVENT
;
6857 XSETFRAME (last_mouse_press_frame
, f
);
6859 *finish
= X_EVENT_DROP
;
6862 else if (event
.type
== ButtonPress
)
6864 last_mouse_press_frame
= Qnil
;
6868 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6869 but I am trying to be cautious. */
6870 else if (event
.type
== ButtonRelease
)
6872 if (!NILP (last_mouse_press_frame
))
6874 f
= XFRAME (last_mouse_press_frame
);
6875 if (f
->output_data
.x
)
6876 SET_SAVED_BUTTON_EVENT
;
6881 #endif /* USE_MOTIF */
6884 #endif /* USE_X_TOOLKIT || USE_GTK */
6888 case CirculateNotify
:
6891 case CirculateRequest
:
6894 case VisibilityNotify
:
6898 /* Someone has changed the keyboard mapping - update the
6900 switch (event
.xmapping
.request
)
6902 case MappingModifier
:
6903 x_find_modifier_meanings (dpyinfo
);
6904 /* This is meant to fall through. */
6905 case MappingKeyboard
:
6906 XRefreshKeyboardMapping (&event
.xmapping
);
6912 #ifdef USE_X_TOOLKIT
6914 if (*finish
!= X_EVENT_DROP
)
6915 XtDispatchEvent (&event
);
6917 #endif /* USE_X_TOOLKIT */
6922 if (inev
.ie
.kind
!= NO_EVENT
)
6924 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6929 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6934 XSETFRAME (frame
, f
);
6940 any_help_event_p
= 1;
6941 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6942 help_echo_object
, help_echo_pos
);
6946 help_echo_string
= Qnil
;
6947 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6957 /* Handles the XEvent EVENT on display DISPLAY.
6958 This is used for event loops outside the normal event handling,
6959 i.e. looping while a popup menu or a dialog is posted.
6961 Returns the value handle_one_xevent sets in the finish argument. */
6963 x_dispatch_event (event
, display
)
6967 struct x_display_info
*dpyinfo
;
6968 int finish
= X_EVENT_NORMAL
;
6970 dpyinfo
= x_display_info_for_display (display
);
6973 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6979 /* Read events coming from the X server.
6980 This routine is called by the SIGIO handler.
6981 We return as soon as there are no more events to be read.
6983 We return the number of characters stored into the buffer,
6984 thus pretending to be `read'.
6986 EXPECTED is nonzero if the caller knows input is available. */
6989 XTread_socket (sd
, expected
, hold_quit
)
6992 struct input_event
*hold_quit
;
6996 int event_found
= 0;
6997 struct x_display_info
*dpyinfo
;
6999 if (interrupt_input_blocked
)
7001 interrupt_input_pending
= 1;
7005 interrupt_input_pending
= 0;
7008 /* So people can tell when we have read the available input. */
7009 input_signal_count
++;
7013 /* Find the display we are supposed to read input for.
7014 It's the one communicating on descriptor SD. */
7015 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
7017 #if 0 /* This ought to be unnecessary; let's verify it. */
7019 /* If available, Xlib uses FIOSNBIO to make the socket
7020 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
7021 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
7022 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
7023 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
7024 #endif /* ! defined (FIOSNBIO) */
7027 #if 0 /* This code can't be made to work, with multiple displays,
7028 and appears not to be used on any system any more.
7029 Also keyboard.c doesn't turn O_NDELAY on and off
7030 for X connections. */
7033 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
7035 extern int read_alarm_should_throw
;
7036 read_alarm_should_throw
= 1;
7037 XPeekEvent (dpyinfo
->display
, &event
);
7038 read_alarm_should_throw
= 0;
7040 #endif /* HAVE_SELECT */
7044 /* For debugging, this gives a way to fake an I/O error. */
7045 if (dpyinfo
== XTread_socket_fake_io_error
)
7047 XTread_socket_fake_io_error
= 0;
7048 x_io_error_quitter (dpyinfo
->display
);
7053 struct input_event inev
;
7055 /* We don't need to EVENT_INIT (inev) here, as
7056 x_session_check_input copies an entire input_event. */
7057 if (x_session_check_input (&inev
))
7059 kbd_buffer_store_event_hold (&inev
, hold_quit
);
7067 while (XPending (dpyinfo
->display
))
7071 XNextEvent (dpyinfo
->display
, &event
);
7074 /* Filter events for the current X input method. */
7075 if (x_filter_event (dpyinfo
, &event
))
7080 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
7082 if (finish
== X_EVENT_GOTO_OUT
)
7085 #endif /* not USE_GTK */
7090 /* For GTK we must use the GTK event loop. But XEvents gets passed
7091 to our filter function above, and then to the big event switch.
7092 We use a bunch of globals to communicate with our filter function,
7093 that is kind of ugly, but it works.
7095 There is no way to do one display at the time, GTK just does events
7096 from all displays. */
7098 while (gtk_events_pending ())
7100 current_count
= count
;
7101 current_hold_quit
= hold_quit
;
7103 gtk_main_iteration ();
7105 count
= current_count
;
7107 current_hold_quit
= 0;
7109 if (current_finish
== X_EVENT_GOTO_OUT
)
7112 #endif /* USE_GTK */
7116 /* On some systems, an X bug causes Emacs to get no more events
7117 when the window is destroyed. Detect that. (1994.) */
7120 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7121 One XNOOP in 100 loops will make Emacs terminate.
7122 B. Bretthauer, 1994 */
7124 if (x_noop_count
>= 100)
7128 if (next_noop_dpyinfo
== 0)
7129 next_noop_dpyinfo
= x_display_list
;
7131 XNoOp (next_noop_dpyinfo
->display
);
7133 /* Each time we get here, cycle through the displays now open. */
7134 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7138 /* If the focus was just given to an auto-raising frame,
7140 /* ??? This ought to be able to handle more than one such frame. */
7141 if (pending_autoraise_frame
)
7143 x_raise_frame (pending_autoraise_frame
);
7144 pending_autoraise_frame
= 0;
7156 /***********************************************************************
7158 ***********************************************************************/
7160 /* Set clipping for output in glyph row ROW. W is the window in which
7161 we operate. GC is the graphics context to set clipping in.
7163 ROW may be a text row or, e.g., a mode line. Text rows must be
7164 clipped to the interior of the window dedicated to text display,
7165 mode lines must be clipped to the whole window. */
7168 x_clip_to_row (w
, row
, area
, gc
)
7170 struct glyph_row
*row
;
7174 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7175 XRectangle clip_rect
;
7176 int window_x
, window_y
, window_width
;
7178 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7180 clip_rect
.x
= window_x
;
7181 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7182 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7183 clip_rect
.width
= window_width
;
7184 clip_rect
.height
= row
->visible_height
;
7186 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7190 /* Draw a hollow box cursor on window W in glyph row ROW. */
7193 x_draw_hollow_cursor (w
, row
)
7195 struct glyph_row
*row
;
7197 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7198 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7199 Display
*dpy
= FRAME_X_DISPLAY (f
);
7202 struct glyph
*cursor_glyph
;
7205 /* Get the glyph the cursor is on. If we can't tell because
7206 the current matrix is invalid or such, give up. */
7207 cursor_glyph
= get_phys_cursor_glyph (w
);
7208 if (cursor_glyph
== NULL
)
7211 /* Compute frame-relative coordinates for phys cursor. */
7212 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7213 wd
= w
->phys_cursor_width
;
7215 /* The foreground of cursor_gc is typically the same as the normal
7216 background color, which can cause the cursor box to be invisible. */
7217 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7218 if (dpyinfo
->scratch_cursor_gc
)
7219 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7221 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7222 GCForeground
, &xgcv
);
7223 gc
= dpyinfo
->scratch_cursor_gc
;
7225 /* Set clipping, draw the rectangle, and reset clipping again. */
7226 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7227 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7228 XSetClipMask (dpy
, gc
, None
);
7232 /* Draw a bar cursor on window W in glyph row ROW.
7234 Implementation note: One would like to draw a bar cursor with an
7235 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7236 Unfortunately, I didn't find a font yet that has this property set.
7240 x_draw_bar_cursor (w
, row
, width
, kind
)
7242 struct glyph_row
*row
;
7244 enum text_cursor_kinds kind
;
7246 struct frame
*f
= XFRAME (w
->frame
);
7247 struct glyph
*cursor_glyph
;
7249 /* If cursor is out of bounds, don't draw garbage. This can happen
7250 in mini-buffer windows when switching between echo area glyphs
7252 cursor_glyph
= get_phys_cursor_glyph (w
);
7253 if (cursor_glyph
== NULL
)
7256 /* If on an image, draw like a normal cursor. That's usually better
7257 visible than drawing a bar, esp. if the image is large so that
7258 the bar might not be in the window. */
7259 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7261 struct glyph_row
*row
;
7262 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7263 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7267 Display
*dpy
= FRAME_X_DISPLAY (f
);
7268 Window window
= FRAME_X_WINDOW (f
);
7269 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7270 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7271 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7274 /* If the glyph's background equals the color we normally draw
7275 the bar cursor in, the bar cursor in its normal color is
7276 invisible. Use the glyph's foreground color instead in this
7277 case, on the assumption that the glyph's colors are chosen so
7278 that the glyph is legible. */
7279 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7280 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7282 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7283 xgcv
.graphics_exposures
= 0;
7286 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7289 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7290 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7294 width
= FRAME_CURSOR_WIDTH (f
);
7295 width
= min (cursor_glyph
->pixel_width
, width
);
7297 w
->phys_cursor_width
= width
;
7298 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7300 if (kind
== BAR_CURSOR
)
7301 XFillRectangle (dpy
, window
, gc
,
7302 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7303 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7304 width
, row
->height
);
7306 XFillRectangle (dpy
, window
, gc
,
7307 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7308 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7309 row
->height
- width
),
7310 cursor_glyph
->pixel_width
,
7313 XSetClipMask (dpy
, gc
, None
);
7318 /* RIF: Define cursor CURSOR on frame F. */
7321 x_define_frame_cursor (f
, cursor
)
7325 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7329 /* RIF: Clear area on frame F. */
7332 x_clear_frame_area (f
, x
, y
, width
, height
)
7334 int x
, y
, width
, height
;
7336 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7337 x
, y
, width
, height
, False
);
7341 /* RIF: Draw cursor on window W. */
7344 x_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
7346 struct glyph_row
*glyph_row
;
7348 int cursor_type
, cursor_width
;
7351 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7355 w
->phys_cursor_type
= cursor_type
;
7356 w
->phys_cursor_on_p
= 1;
7358 if (glyph_row
->exact_window_width_line_p
7359 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
7361 glyph_row
->cursor_in_fringe_p
= 1;
7362 draw_fringe_bitmap (w
, glyph_row
, 0);
7365 switch (cursor_type
)
7367 case HOLLOW_BOX_CURSOR
:
7368 x_draw_hollow_cursor (w
, glyph_row
);
7371 case FILLED_BOX_CURSOR
:
7372 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7376 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7380 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7384 w
->phys_cursor_width
= 0;
7392 if (w
== XWINDOW (f
->selected_window
))
7393 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7394 xic_set_preeditarea (w
, x
, y
);
7399 if (updating_frame
!= f
)
7400 XFlush (FRAME_X_DISPLAY (f
));
7407 /* Make the x-window of frame F use the gnu icon bitmap. */
7410 x_bitmap_icon (f
, file
)
7416 if (FRAME_X_WINDOW (f
) == 0)
7419 /* Free up our existing icon bitmap and mask if any. */
7420 if (f
->output_data
.x
->icon_bitmap
> 0)
7421 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7422 f
->output_data
.x
->icon_bitmap
= 0;
7427 /* Use gtk_window_set_icon_from_file () if available,
7428 It's not restricted to bitmaps */
7429 if (xg_set_icon (f
, file
))
7431 #endif /* USE_GTK */
7432 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7433 x_create_bitmap_mask (f
, bitmap_id
);
7437 /* Create the GNU bitmap and mask if necessary. */
7438 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7442 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7444 if (xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7447 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7449 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7450 #endif /* USE_GTK */
7451 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
7453 /* If all else fails, use the (black and white) xbm image. */
7456 rc
= x_create_bitmap_from_data (f
, gnu_xbm_bits
,
7457 gnu_xbm_width
, gnu_xbm_height
);
7461 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7462 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7466 /* The first time we create the GNU bitmap and mask,
7467 this increments the ref-count one extra time.
7468 As a result, the GNU bitmap and mask are never freed.
7469 That way, we don't have to worry about allocating it again. */
7470 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7472 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7475 x_wm_set_icon_pixmap (f
, bitmap_id
);
7476 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7482 /* Make the x-window of frame F use a rectangle with text.
7483 Use ICON_NAME as the text. */
7486 x_text_icon (f
, icon_name
)
7490 if (FRAME_X_WINDOW (f
) == 0)
7496 text
.value
= (unsigned char *) icon_name
;
7497 text
.encoding
= XA_STRING
;
7499 text
.nitems
= strlen (icon_name
);
7500 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7502 #else /* not HAVE_X11R4 */
7503 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), icon_name
);
7504 #endif /* not HAVE_X11R4 */
7506 if (f
->output_data
.x
->icon_bitmap
> 0)
7507 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7508 f
->output_data
.x
->icon_bitmap
= 0;
7509 x_wm_set_icon_pixmap (f
, 0);
7514 #define X_ERROR_MESSAGE_SIZE 200
7516 /* If non-nil, this should be a string.
7517 It means catch X errors and store the error message in this string.
7519 The reason we use a stack is that x_catch_error/x_uncatch_error can
7520 be called from a signal handler.
7523 struct x_error_message_stack
{
7524 char string
[X_ERROR_MESSAGE_SIZE
];
7526 struct x_error_message_stack
*prev
;
7528 static struct x_error_message_stack
*x_error_message
;
7530 /* An X error handler which stores the error message in
7531 *x_error_message. This is called from x_error_handler if
7532 x_catch_errors is in effect. */
7535 x_error_catcher (display
, error
)
7539 XGetErrorText (display
, error
->error_code
,
7540 x_error_message
->string
,
7541 X_ERROR_MESSAGE_SIZE
);
7544 /* Begin trapping X errors for display DPY. Actually we trap X errors
7545 for all displays, but DPY should be the display you are actually
7548 After calling this function, X protocol errors no longer cause
7549 Emacs to exit; instead, they are recorded in the string
7550 stored in *x_error_message.
7552 Calling x_check_errors signals an Emacs error if an X error has
7553 occurred since the last call to x_catch_errors or x_check_errors.
7555 Calling x_uncatch_errors resumes the normal error handling. */
7557 void x_check_errors ();
7560 x_catch_errors (dpy
)
7563 struct x_error_message_stack
*data
= xmalloc (sizeof (*data
));
7565 /* Make sure any errors from previous requests have been dealt with. */
7569 data
->string
[0] = 0;
7570 data
->prev
= x_error_message
;
7571 x_error_message
= data
;
7574 /* Undo the last x_catch_errors call.
7575 DPY should be the display that was passed to x_catch_errors. */
7580 struct x_error_message_stack
*tmp
;
7584 /* The display may have been closed before this function is called.
7585 Check if it is still open before calling XSync. */
7586 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7587 XSync (x_error_message
->dpy
, False
);
7589 tmp
= x_error_message
;
7590 x_error_message
= x_error_message
->prev
;
7595 /* If any X protocol errors have arrived since the last call to
7596 x_catch_errors or x_check_errors, signal an Emacs error using
7597 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7600 x_check_errors (dpy
, format
)
7604 /* Make sure to catch any errors incurred so far. */
7607 if (x_error_message
->string
[0])
7609 char string
[X_ERROR_MESSAGE_SIZE
];
7610 bcopy (x_error_message
->string
, string
, X_ERROR_MESSAGE_SIZE
);
7611 x_uncatch_errors ();
7612 error (format
, string
);
7616 /* Nonzero if we had any X protocol errors
7617 since we did x_catch_errors on DPY. */
7620 x_had_errors_p (dpy
)
7623 /* Make sure to catch any errors incurred so far. */
7626 return x_error_message
->string
[0] != 0;
7629 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7632 x_clear_errors (dpy
)
7635 x_error_message
->string
[0] = 0;
7638 /* Close off all unclosed x_catch_errors calls. */
7641 x_fully_uncatch_errors ()
7643 while (x_error_message
)
7644 x_uncatch_errors ();
7647 /* Nonzero if x_catch_errors has been done and not yet canceled. */
7650 x_catching_errors ()
7652 return x_error_message
!= 0;
7656 static unsigned int x_wire_count
;
7659 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7664 /* Handle SIGPIPE, which can happen when the connection to a server
7665 simply goes away. SIGPIPE is handled by x_connection_signal.
7666 Don't need to do anything, because the write which caused the
7667 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7668 which will do the appropriate cleanup for us. */
7671 x_connection_signal (signalnum
) /* If we don't have an argument, */
7672 int signalnum
; /* some compilers complain in signal calls. */
7675 /* USG systems forget handlers when they are used;
7676 must reestablish each time */
7677 signal (signalnum
, x_connection_signal
);
7682 /************************************************************************
7684 ************************************************************************/
7686 /* Error message passed to x_connection_closed. */
7688 static char *error_msg
;
7690 /* Function installed as fatal_error_signal_hook in
7691 x_connection_closed. Print the X error message, and exit normally,
7692 instead of dumping core when XtCloseDisplay fails. */
7695 x_fatal_error_signal ()
7697 fprintf (stderr
, "%s\n", error_msg
);
7701 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7702 the text of an error message that lead to the connection loss. */
7705 x_connection_closed (dpy
, error_message
)
7707 char *error_message
;
7709 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7710 Lisp_Object frame
, tail
;
7712 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7713 strcpy (error_msg
, error_message
);
7714 handling_signal
= 0;
7716 /* Prevent being called recursively because of an error condition
7717 below. Otherwise, we might end up with printing ``can't find per
7718 display information'' in the recursive call instead of printing
7719 the original message here. */
7720 x_catch_errors (dpy
);
7722 /* We have to close the display to inform Xt that it doesn't
7723 exist anymore. If we don't, Xt will continue to wait for
7724 events from the display. As a consequence, a sequence of
7726 M-x make-frame-on-display RET :1 RET
7727 ...kill the new frame, so that we get an IO error...
7728 M-x make-frame-on-display RET :1 RET
7730 will indefinitely wait in Xt for events for display `:1', opened
7731 in the first class to make-frame-on-display.
7733 Closing the display is reported to lead to a bus error on
7734 OpenWindows in certain situations. I suspect that is a bug
7735 in OpenWindows. I don't know how to cicumvent it here. */
7737 #ifdef USE_X_TOOLKIT
7738 /* If DPYINFO is null, this means we didn't open the display
7739 in the first place, so don't try to close it. */
7742 extern void (*fatal_error_signal_hook
) P_ ((void));
7743 fatal_error_signal_hook
= x_fatal_error_signal
;
7744 XtCloseDisplay (dpy
);
7745 fatal_error_signal_hook
= NULL
;
7751 xg_display_close (dpyinfo
->display
);
7754 /* Indicate that this display is dead. */
7756 dpyinfo
->display
= 0;
7758 /* First delete frames whose mini-buffers are on frames
7759 that are on the dead display. */
7760 FOR_EACH_FRAME (tail
, frame
)
7762 Lisp_Object minibuf_frame
;
7764 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7765 if (FRAME_X_P (XFRAME (frame
))
7766 && FRAME_X_P (XFRAME (minibuf_frame
))
7767 && ! EQ (frame
, minibuf_frame
)
7768 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7769 Fdelete_frame (frame
, Qt
);
7772 /* Now delete all remaining frames on the dead display.
7773 We are now sure none of these is used as the mini-buffer
7774 for another frame that we need to delete. */
7775 FOR_EACH_FRAME (tail
, frame
)
7776 if (FRAME_X_P (XFRAME (frame
))
7777 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7779 /* Set this to t so that Fdelete_frame won't get confused
7780 trying to find a replacement. */
7781 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7782 Fdelete_frame (frame
, Qt
);
7786 x_delete_display (dpyinfo
);
7788 x_uncatch_errors ();
7790 if (x_display_list
== 0)
7792 fprintf (stderr
, "%s\n", error_msg
);
7793 shut_down_emacs (0, 0, Qnil
);
7797 /* Ordinary stack unwind doesn't deal with these. */
7799 sigunblock (sigmask (SIGIO
));
7801 sigunblock (sigmask (SIGALRM
));
7802 TOTALLY_UNBLOCK_INPUT
;
7804 clear_waiting_for_input ();
7805 error ("%s", error_msg
);
7808 /* We specifically use it before defining it, so that gcc doesn't inline it,
7809 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7810 static void x_error_quitter
P_ ((Display
*, XErrorEvent
*));
7812 /* This is the first-level handler for X protocol errors.
7813 It calls x_error_quitter or x_error_catcher. */
7816 x_error_handler (display
, error
)
7820 if (x_error_message
)
7821 x_error_catcher (display
, error
);
7823 x_error_quitter (display
, error
);
7827 /* This is the usual handler for X protocol errors.
7828 It kills all frames on the display that we got the error for.
7829 If that was the only one, it prints an error message and kills Emacs. */
7831 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7833 #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */
7834 #define NO_INLINE __attribute__((noinline))
7839 /* Some versions of GNU/Linux define noinline in their headers. */
7845 /* On older GCC versions, just putting x_error_quitter
7846 after x_error_handler prevents inlining into the former. */
7848 static void NO_INLINE
7849 x_error_quitter (display
, error
)
7853 char buf
[256], buf1
[356];
7855 /* Ignore BadName errors. They can happen because of fonts
7856 or colors that are not defined. */
7858 if (error
->error_code
== BadName
)
7861 /* Note that there is no real way portable across R3/R4 to get the
7862 original error handler. */
7864 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7865 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7866 buf
, error
->request_code
);
7867 x_connection_closed (display
, buf1
);
7871 /* This is the handler for X IO errors, always.
7872 It kills all frames on the display that we lost touch with.
7873 If that was the only one, it prints an error message and kills Emacs. */
7876 x_io_error_quitter (display
)
7881 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7882 x_connection_closed (display
, buf
);
7886 /* Changing the font of the frame. */
7888 /* Give frame F the font named FONTNAME as its default font, and
7889 return the full name of that font. FONTNAME may be a wildcard
7890 pattern; in that case, we choose some font that fits the pattern.
7891 The return value shows which font we chose. */
7894 x_new_font (f
, fontname
)
7896 register char *fontname
;
7898 struct font_info
*fontp
7899 = FS_LOAD_FONT (f
, 0, fontname
, -1);
7904 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
7905 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
7906 FRAME_FONTSET (f
) = -1;
7908 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
7909 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
7910 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
7912 compute_fringe_widths (f
, 1);
7914 /* Compute the scroll bar width in character columns. */
7915 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7917 int wid
= FRAME_COLUMN_WIDTH (f
);
7918 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7919 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7923 int wid
= FRAME_COLUMN_WIDTH (f
);
7924 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7927 /* Now make the frame display the given font. */
7928 if (FRAME_X_WINDOW (f
) != 0)
7930 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
7931 FRAME_FONT (f
)->fid
);
7932 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
7933 FRAME_FONT (f
)->fid
);
7934 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
7935 FRAME_FONT (f
)->fid
);
7937 /* Don't change the size of a tip frame; there's no point in
7938 doing it because it's done in Fx_show_tip, and it leads to
7939 problems because the tip frame has no widget. */
7940 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7941 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7944 return build_string (fontp
->full_name
);
7947 /* Give frame F the fontset named FONTSETNAME as its default font, and
7948 return the full name of that fontset. FONTSETNAME may be a wildcard
7949 pattern; in that case, we choose some fontset that fits the pattern.
7950 The return value shows which fontset we chose. */
7953 x_new_fontset (f
, fontsetname
)
7957 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
7963 if (FRAME_FONTSET (f
) == fontset
)
7964 /* This fontset is already set in frame F. There's nothing more
7966 return fontset_name (fontset
);
7968 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
7970 if (!STRINGP (result
))
7971 /* Can't load ASCII font. */
7974 /* Since x_new_font doesn't update any fontset information, do it now. */
7975 FRAME_FONTSET (f
) = fontset
;
7979 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7980 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7983 return build_string (fontsetname
);
7987 /***********************************************************************
7989 ***********************************************************************/
7995 /* XIM destroy callback function, which is called whenever the
7996 connection to input method XIM dies. CLIENT_DATA contains a
7997 pointer to the x_display_info structure corresponding to XIM. */
8000 xim_destroy_callback (xim
, client_data
, call_data
)
8002 XPointer client_data
;
8005 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
8006 Lisp_Object frame
, tail
;
8010 /* No need to call XDestroyIC.. */
8011 FOR_EACH_FRAME (tail
, frame
)
8013 struct frame
*f
= XFRAME (frame
);
8014 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
8016 FRAME_XIC (f
) = NULL
;
8017 xic_free_xfontset (f
);
8021 /* No need to call XCloseIM. */
8022 dpyinfo
->xim
= NULL
;
8023 XFree (dpyinfo
->xim_styles
);
8027 #endif /* HAVE_X11R6 */
8030 /* This isn't prototyped in OSF 5.0 or 5.1a. */
8031 extern char *XSetIMValues
P_ ((XIM
, ...));
8034 /* Open the connection to the XIM server on display DPYINFO.
8035 RESOURCE_NAME is the resource name Emacs uses. */
8038 xim_open_dpy (dpyinfo
, resource_name
)
8039 struct x_display_info
*dpyinfo
;
8040 char *resource_name
;
8047 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
8054 XIMCallback destroy
;
8057 /* Get supported styles and XIM values. */
8058 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
8061 destroy
.callback
= xim_destroy_callback
;
8062 destroy
.client_data
= (XPointer
)dpyinfo
;
8063 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8069 #endif /* HAVE_XIM */
8070 dpyinfo
->xim
= NULL
;
8074 #ifdef HAVE_X11R6_XIM
8078 struct x_display_info
*dpyinfo
;
8079 char *resource_name
;
8082 /* XIM instantiate callback function, which is called whenever an XIM
8083 server is available. DISPLAY is the display of the XIM.
8084 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8085 when the callback was registered. */
8088 xim_instantiate_callback (display
, client_data
, call_data
)
8090 XPointer client_data
;
8093 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8094 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8096 /* We don't support multiple XIM connections. */
8100 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8102 /* Create XIC for the existing frames on the same display, as long
8103 as they have no XIC. */
8104 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8106 Lisp_Object tail
, frame
;
8109 FOR_EACH_FRAME (tail
, frame
)
8111 struct frame
*f
= XFRAME (frame
);
8113 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8114 if (FRAME_XIC (f
) == NULL
)
8116 create_frame_xic (f
);
8117 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8118 xic_set_statusarea (f
);
8119 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8121 struct window
*w
= XWINDOW (f
->selected_window
);
8122 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8131 #endif /* HAVE_X11R6_XIM */
8134 /* Open a connection to the XIM server on display DPYINFO.
8135 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8136 connection only at the first time. On X11R6, open the connection
8137 in the XIM instantiate callback function. */
8140 xim_initialize (dpyinfo
, resource_name
)
8141 struct x_display_info
*dpyinfo
;
8142 char *resource_name
;
8147 #ifdef HAVE_X11R6_XIM
8148 struct xim_inst_t
*xim_inst
;
8151 dpyinfo
->xim
= NULL
;
8152 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8153 xim_inst
->dpyinfo
= dpyinfo
;
8154 len
= strlen (resource_name
);
8155 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8156 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
8157 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8158 resource_name
, EMACS_CLASS
,
8159 xim_instantiate_callback
,
8160 /* This is XPointer in XFree86
8161 but (XPointer *) on Tru64, at
8162 least, hence the configure test. */
8163 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8164 #else /* not HAVE_X11R6_XIM */
8165 dpyinfo
->xim
= NULL
;
8166 xim_open_dpy (dpyinfo
, resource_name
);
8167 #endif /* not HAVE_X11R6_XIM */
8171 #endif /* HAVE_XIM */
8172 dpyinfo
->xim
= NULL
;
8176 /* Close the connection to the XIM server on display DPYINFO. */
8179 xim_close_dpy (dpyinfo
)
8180 struct x_display_info
*dpyinfo
;
8185 #ifdef HAVE_X11R6_XIM
8186 if (dpyinfo
->display
)
8187 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8189 xim_instantiate_callback
, NULL
);
8190 #endif /* not HAVE_X11R6_XIM */
8191 if (dpyinfo
->display
)
8192 XCloseIM (dpyinfo
->xim
);
8193 dpyinfo
->xim
= NULL
;
8194 XFree (dpyinfo
->xim_styles
);
8196 #endif /* HAVE_XIM */
8199 #endif /* not HAVE_X11R6_XIM */
8203 /* Calculate the absolute position in frame F
8204 from its current recorded position values and gravity. */
8207 x_calc_absolute_position (f
)
8210 int flags
= f
->size_hint_flags
;
8212 /* We have nothing to do if the current position
8213 is already for the top-left corner. */
8214 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8217 /* Treat negative positions as relative to the leftmost bottommost
8218 position that fits on the screen. */
8219 if (flags
& XNegative
)
8220 f
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
8221 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
);
8224 int height
= FRAME_PIXEL_HEIGHT (f
);
8226 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8227 /* Something is fishy here. When using Motif, starting Emacs with
8228 `-g -0-0', the frame appears too low by a few pixels.
8230 This seems to be so because initially, while Emacs is starting,
8231 the column widget's height and the frame's pixel height are
8232 different. The column widget's height is the right one. In
8233 later invocations, when Emacs is up, the frame's pixel height
8236 It's not obvious where the initial small difference comes from.
8237 2000-12-01, gerd. */
8239 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8242 if (flags
& YNegative
)
8243 f
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
- height
+ f
->top_pos
);
8246 /* The left_pos and top_pos
8247 are now relative to the top and left screen edges,
8248 so the flags should correspond. */
8249 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8252 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8253 to really change the position, and 0 when calling from
8254 x_make_frame_visible (in that case, XOFF and YOFF are the current
8255 position values). It is -1 when calling from x_set_frame_parameters,
8256 which means, do adjust for borders but don't change the gravity. */
8259 x_set_offset (f
, xoff
, yoff
, change_gravity
)
8261 register int xoff
, yoff
;
8264 int modified_top
, modified_left
;
8266 if (change_gravity
!= 0)
8268 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8269 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8273 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8275 f
->size_hint_flags
|= XNegative
;
8277 f
->size_hint_flags
|= YNegative
;
8278 f
->win_gravity
= NorthWestGravity
;
8280 x_calc_absolute_position (f
);
8283 x_wm_set_size_hint (f
, (long) 0, 0);
8285 modified_left
= f
->left_pos
;
8286 modified_top
= f
->top_pos
;
8288 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8290 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8291 than the WM decorations. So we use the calculated offset instead
8292 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8293 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8294 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8297 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8298 modified_left
, modified_top
);
8300 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8301 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8304 /* change_gravity is non-zero when this function is called from Lisp to
8305 programmatically move a frame. In that case, we call
8306 x_check_expected_move to discover if we have a "Type A" or "Type B"
8307 window manager, and, for a "Type A" window manager, adjust the position
8310 We call x_check_expected_move if a programmatic move occurred, and
8311 either the window manager type (A/B) is unknown or it is Type A but we
8312 need to compute the top/left offset adjustment for this frame. */
8314 if (change_gravity
!= 0 &&
8315 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8316 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8317 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8318 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8319 x_check_expected_move (f
, modified_left
, modified_top
);
8324 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8325 on the root window for frame F contains ATOMNAME.
8326 This is how a WM check shall be done according to the Window Manager
8327 Specification/Extended Window Manager Hints at
8328 http://freedesktop.org/wiki/Standards_2fwm_2dspec. */
8331 wm_supports (f
, atomname
)
8333 const char *atomname
;
8336 unsigned long actual_size
, bytes_remaining
;
8337 int i
, rc
, actual_format
;
8339 Window wmcheck_window
;
8340 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8341 Window target_window
= dpyinfo
->root_window
;
8342 long max_len
= 65536;
8343 Display
*dpy
= FRAME_X_DISPLAY (f
);
8344 unsigned char *tmp_data
= NULL
;
8345 Atom target_type
= XA_WINDOW
;
8350 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTING_WM_CHECK", False
);
8352 x_catch_errors (dpy
);
8353 rc
= XGetWindowProperty (dpy
, target_window
,
8354 prop_atom
, 0, max_len
, False
, target_type
,
8355 &actual_type
, &actual_format
, &actual_size
,
8356 &bytes_remaining
, &tmp_data
);
8358 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8360 if (tmp_data
) XFree (tmp_data
);
8361 x_uncatch_errors ();
8366 wmcheck_window
= *(Window
*) tmp_data
;
8369 /* Check if window exists. */
8370 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8372 if (x_had_errors_p (dpy
))
8374 x_uncatch_errors ();
8379 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8381 /* Window changed, reload atoms */
8382 if (dpyinfo
->net_supported_atoms
!= NULL
)
8383 XFree (dpyinfo
->net_supported_atoms
);
8384 dpyinfo
->net_supported_atoms
= NULL
;
8385 dpyinfo
->nr_net_supported_atoms
= 0;
8386 dpyinfo
->net_supported_window
= 0;
8388 target_type
= XA_ATOM
;
8389 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTED", False
);
8391 rc
= XGetWindowProperty (dpy
, target_window
,
8392 prop_atom
, 0, max_len
, False
, target_type
,
8393 &actual_type
, &actual_format
, &actual_size
,
8394 &bytes_remaining
, &tmp_data
);
8396 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8398 if (tmp_data
) XFree (tmp_data
);
8399 x_uncatch_errors ();
8404 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8405 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8406 dpyinfo
->net_supported_window
= wmcheck_window
;
8410 want_atom
= XInternAtom (dpy
, atomname
, False
);
8412 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8413 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8415 x_uncatch_errors ();
8421 /* Do fullscreen as specified in extended window manager hints */
8424 do_ewmh_fullscreen (f
)
8427 int have_net_atom
= wm_supports (f
, "_NET_WM_STATE");
8432 const char *atom
= "_NET_WM_STATE";
8433 const char *fs
= "_NET_WM_STATE_FULLSCREEN";
8434 const char *fw
= "_NET_WM_STATE_MAXIMIZED_HORZ";
8435 const char *fh
= "_NET_WM_STATE_MAXIMIZED_VERT";
8436 const char *what
= NULL
;
8438 XSETFRAME (frame
, f
);
8440 /* If there are _NET_ atoms we assume we have extended window manager
8442 switch (f
->want_fullscreen
)
8444 case FULLSCREEN_BOTH
:
8447 case FULLSCREEN_WIDTH
:
8450 case FULLSCREEN_HEIGHT
:
8455 if (what
!= NULL
&& !wm_supports (f
, what
)) return 0;
8458 Fx_send_client_event (frame
, make_number (0), frame
,
8459 make_unibyte_string (atom
, strlen (atom
)),
8461 Fcons (make_number (0), /* Remove */
8463 (make_unibyte_string (fs
,
8466 Fx_send_client_event (frame
, make_number (0), frame
,
8467 make_unibyte_string (atom
, strlen (atom
)),
8469 Fcons (make_number (0), /* Remove */
8471 (make_unibyte_string (fh
,
8474 Fx_send_client_event (frame
, make_number (0), frame
,
8475 make_unibyte_string (atom
, strlen (atom
)),
8477 Fcons (make_number (0), /* Remove */
8479 (make_unibyte_string (fw
,
8482 f
->want_fullscreen
= FULLSCREEN_NONE
;
8484 Fx_send_client_event (frame
, make_number (0), frame
,
8485 make_unibyte_string (atom
, strlen (atom
)),
8487 Fcons (make_number (1), /* Add */
8489 (make_unibyte_string (what
,
8494 return have_net_atom
;
8498 XTfullscreen_hook (f
)
8501 if (f
->async_visible
)
8504 do_ewmh_fullscreen (f
);
8511 /* Check if we need to resize the frame due to a fullscreen request.
8512 If so needed, resize the frame. */
8514 x_check_fullscreen (f
)
8517 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
8519 int width
, height
, ign
;
8521 if (do_ewmh_fullscreen (f
))
8524 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8526 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
8528 /* We do not need to move the window, it shall be taken care of
8529 when setting WM manager hints.
8530 If the frame is visible already, the position is checked by
8531 x_check_expected_move. */
8532 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8534 change_frame_size (f
, height
, width
, 0, 1, 0);
8535 SET_FRAME_GARBAGED (f
);
8536 cancel_mouse_face (f
);
8538 /* Wait for the change of frame size to occur */
8539 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
8544 /* This function is called by x_set_offset to determine whether the window
8545 manager interfered with the positioning of the frame. Type A window
8546 managers position the surrounding window manager decorations a small
8547 amount above and left of the user-supplied position. Type B window
8548 managers position the surrounding window manager decorations at the
8549 user-specified position. If we detect a Type A window manager, we
8550 compensate by moving the window right and down by the proper amount. */
8553 x_check_expected_move (f
, expected_left
, expected_top
)
8558 int current_left
= 0, current_top
= 0;
8560 /* x_real_positions returns the left and top offsets of the outermost
8561 window manager window around the frame. */
8563 x_real_positions (f
, ¤t_left
, ¤t_top
);
8565 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8567 /* It's a "Type A" window manager. */
8572 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8573 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8574 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8576 /* Now fix the mispositioned frame's location. */
8578 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8579 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8581 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8582 adjusted_left
, adjusted_top
);
8584 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8587 /* It's a "Type B" window manager. We don't have to adjust the
8588 frame's position. */
8590 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8594 /* Wait for XGetGeometry to return up-to-date position information for a
8595 recently-moved frame. Call this immediately after calling XMoveWindow.
8596 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8597 frame has been moved to, so we use a fuzzy position comparison instead
8598 of an exact comparison. */
8601 x_sync_with_move (f
, left
, top
, fuzzy
)
8603 int left
, top
, fuzzy
;
8607 while (count
++ < 50)
8609 int current_left
= 0, current_top
= 0;
8611 /* In theory, this call to XSync only needs to happen once, but in
8612 practice, it doesn't seem to work, hence the need for the surrounding
8615 XSync (FRAME_X_DISPLAY (f
), False
);
8616 x_real_positions (f
, ¤t_left
, ¤t_top
);
8620 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8623 if (abs (current_left
- left
) <= 10 && abs (current_top
- top
) <= 40)
8626 else if (current_left
== left
&& current_top
== top
)
8630 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8631 will then return up-to-date position info. */
8633 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8637 /* Change the size of frame F's X window to COLS/ROWS in the case F
8638 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8639 top-left-corner window gravity for this size change and subsequent
8640 size changes. Otherwise we leave the window gravity unchanged. */
8643 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
8648 int pixelwidth
, pixelheight
;
8650 check_frame_size (f
, &rows
, &cols
);
8651 f
->scroll_bar_actual_width
8652 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8654 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
8655 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
8656 : (FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
)));
8658 compute_fringe_widths (f
, 0);
8660 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
8661 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
8663 f
->win_gravity
= NorthWestGravity
;
8664 x_wm_set_size_hint (f
, (long) 0, 0);
8666 XSync (FRAME_X_DISPLAY (f
), False
);
8667 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8668 pixelwidth
, pixelheight
);
8670 /* Now, strictly speaking, we can't be sure that this is accurate,
8671 but the window manager will get around to dealing with the size
8672 change request eventually, and we'll hear how it went when the
8673 ConfigureNotify event gets here.
8675 We could just not bother storing any of this information here,
8676 and let the ConfigureNotify event set everything up, but that
8677 might be kind of confusing to the Lisp code, since size changes
8678 wouldn't be reported in the frame parameters until some random
8679 point in the future when the ConfigureNotify event arrives.
8681 We pass 1 for DELAY since we can't run Lisp code inside of
8683 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8684 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8685 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8687 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8688 receive in the ConfigureNotify event; if we get what we asked
8689 for, then the event won't cause the screen to become garbaged, so
8690 we have to make sure to do it here. */
8691 SET_FRAME_GARBAGED (f
);
8693 XFlush (FRAME_X_DISPLAY (f
));
8697 /* Call this to change the size of frame F's x-window.
8698 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8699 for this size change and subsequent size changes.
8700 Otherwise we leave the window gravity unchanged. */
8703 x_set_window_size (f
, change_gravity
, cols
, rows
)
8711 if (FRAME_GTK_WIDGET (f
))
8712 xg_frame_set_char_size (f
, cols
, rows
);
8714 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8717 if (f
->output_data
.x
->widget
!= NULL
)
8719 /* The x and y position of the widget is clobbered by the
8720 call to XtSetValues within EmacsFrameSetCharSize.
8721 This is a real kludge, but I don't understand Xt so I can't
8722 figure out a correct fix. Can anyone else tell me? -- rms. */
8723 int xpos
= f
->output_data
.x
->widget
->core
.x
;
8724 int ypos
= f
->output_data
.x
->widget
->core
.y
;
8725 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
8726 f
->output_data
.x
->widget
->core
.x
= xpos
;
8727 f
->output_data
.x
->widget
->core
.y
= ypos
;
8730 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8732 #else /* not USE_X_TOOLKIT */
8734 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8736 #endif /* not USE_X_TOOLKIT */
8738 /* If cursor was outside the new size, mark it as off. */
8739 mark_window_cursors_off (XWINDOW (f
->root_window
));
8741 /* Clear out any recollection of where the mouse highlighting was,
8742 since it might be in a place that's outside the new frame size.
8743 Actually checking whether it is outside is a pain in the neck,
8744 so don't try--just let the highlighting be done afresh with new size. */
8745 cancel_mouse_face (f
);
8750 /* Mouse warping. */
8753 x_set_mouse_position (f
, x
, y
)
8759 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8760 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8762 if (pix_x
< 0) pix_x
= 0;
8763 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8765 if (pix_y
< 0) pix_y
= 0;
8766 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8770 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8771 0, 0, 0, 0, pix_x
, pix_y
);
8775 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8778 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
8784 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8785 0, 0, 0, 0, pix_x
, pix_y
);
8789 /* focus shifting, raising and lowering. */
8792 x_focus_on_frame (f
)
8795 #if 0 /* This proves to be unpleasant. */
8799 /* I don't think that the ICCCM allows programs to do things like this
8800 without the interaction of the window manager. Whatever you end up
8801 doing with this code, do it to x_unfocus_frame too. */
8802 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8803 RevertToPointerRoot
, CurrentTime
);
8812 /* Look at the remarks in x_focus_on_frame. */
8813 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8814 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8815 RevertToPointerRoot
, CurrentTime
);
8819 /* Raise frame F. */
8826 if (f
->async_visible
)
8827 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8829 XFlush (FRAME_X_DISPLAY (f
));
8833 /* Lower frame F. */
8839 if (f
->async_visible
)
8842 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8843 XFlush (FRAME_X_DISPLAY (f
));
8849 XTframe_raise_lower (f
, raise_flag
)
8855 /* The following code is needed for `raise-frame' to work on
8856 some versions of metacity; see Window Manager
8857 Specification/Extended Window Manager Hints at
8858 http://freedesktop.org/wiki/Standards_2fwm_2dspec */
8861 /* However, on other versions (metacity 2.17.2-1.fc7), it
8862 reportedly causes hangs when resizing frames. */
8864 const char *atom
= "_NET_ACTIVE_WINDOW";
8865 if (f
->async_visible
&& wm_supports (f
, atom
))
8868 XSETFRAME (frame
, f
);
8869 Fx_send_client_event (frame
, make_number (0), frame
,
8870 make_unibyte_string (atom
, strlen (atom
)),
8872 Fcons (make_number (1),
8873 Fcons (make_number (last_user_time
),
8884 /* Change of visibility. */
8886 /* This tries to wait until the frame is really visible.
8887 However, if the window manager asks the user where to position
8888 the frame, this will return before the user finishes doing that.
8889 The frame will not actually be visible at that time,
8890 but it will become visible later when the window manager
8891 finishes with it. */
8894 x_make_frame_visible (f
)
8898 int original_top
, original_left
;
8899 int retry_count
= 2;
8905 type
= x_icon_type (f
);
8907 x_bitmap_icon (f
, type
);
8909 if (! FRAME_VISIBLE_P (f
))
8911 /* We test FRAME_GARBAGED_P here to make sure we don't
8912 call x_set_offset a second time
8913 if we get to x_make_frame_visible a second time
8914 before the window gets really visible. */
8915 if (! FRAME_ICONIFIED_P (f
)
8916 && ! f
->output_data
.x
->asked_for_visible
)
8917 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8919 f
->output_data
.x
->asked_for_visible
= 1;
8921 if (! EQ (Vx_no_window_manager
, Qt
))
8922 x_wm_set_window_state (f
, NormalState
);
8923 #ifdef USE_X_TOOLKIT
8924 /* This was XtPopup, but that did nothing for an iconified frame. */
8925 XtMapWidget (f
->output_data
.x
->widget
);
8926 #else /* not USE_X_TOOLKIT */
8928 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8929 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8931 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8932 #endif /* not USE_GTK */
8933 #endif /* not USE_X_TOOLKIT */
8934 #if 0 /* This seems to bring back scroll bars in the wrong places
8935 if the window configuration has changed. They seem
8936 to come back ok without this. */
8937 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8938 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8942 XFlush (FRAME_X_DISPLAY (f
));
8944 /* Synchronize to ensure Emacs knows the frame is visible
8945 before we do anything else. We do this loop with input not blocked
8946 so that incoming events are handled. */
8950 /* This must be before UNBLOCK_INPUT
8951 since events that arrive in response to the actions above
8952 will set it when they are handled. */
8953 int previously_visible
= f
->output_data
.x
->has_been_visible
;
8955 original_left
= f
->left_pos
;
8956 original_top
= f
->top_pos
;
8958 /* This must come after we set COUNT. */
8961 /* We unblock here so that arriving X events are processed. */
8963 /* Now move the window back to where it was "supposed to be".
8964 But don't do it if the gravity is negative.
8965 When the gravity is negative, this uses a position
8966 that is 3 pixels too low. Perhaps that's really the border width.
8968 Don't do this if the window has never been visible before,
8969 because the window manager may choose the position
8970 and we don't want to override it. */
8972 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
8973 && f
->win_gravity
== NorthWestGravity
8974 && previously_visible
)
8978 unsigned int width
, height
, border
, depth
;
8982 /* On some window managers (such as FVWM) moving an existing
8983 window, even to the same place, causes the window manager
8984 to introduce an offset. This can cause the window to move
8985 to an unexpected location. Check the geometry (a little
8986 slow here) and then verify that the window is in the right
8987 place. If the window is not in the right place, move it
8988 there, and take the potential window manager hit. */
8989 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8990 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
8992 if (original_left
!= x
|| original_top
!= y
)
8993 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8994 original_left
, original_top
);
8999 XSETFRAME (frame
, f
);
9001 /* Wait until the frame is visible. Process X events until a
9002 MapNotify event has been seen, or until we think we won't get a
9003 MapNotify at all.. */
9004 for (count
= input_signal_count
+ 10;
9005 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9007 /* Force processing of queued events. */
9010 /* Machines that do polling rather than SIGIO have been
9011 observed to go into a busy-wait here. So we'll fake an
9012 alarm signal to let the handler know that there's something
9013 to be read. We used to raise a real alarm, but it seems
9014 that the handler isn't always enabled here. This is
9016 if (input_polling_used ())
9018 /* It could be confusing if a real alarm arrives while
9019 processing the fake one. Turn it off and let the
9020 handler reset it. */
9021 extern void poll_for_input_1
P_ ((void));
9022 int old_poll_suppress_count
= poll_suppress_count
;
9023 poll_suppress_count
= 1;
9024 poll_for_input_1 ();
9025 poll_suppress_count
= old_poll_suppress_count
;
9028 /* See if a MapNotify event has been processed. */
9029 FRAME_SAMPLE_VISIBILITY (f
);
9034 (let ((f (selected-frame)))
9038 the frame is not raised with various window managers on
9039 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9040 unknown reason, the call to XtMapWidget is completely ignored.
9041 Mapping the widget a second time works. */
9043 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9048 /* Change from mapped state to withdrawn state. */
9050 /* Make the frame visible (mapped and not iconified). */
9053 x_make_frame_invisible (f
)
9058 /* Use the frame's outermost window, not the one we normally draw on. */
9059 window
= FRAME_OUTER_WINDOW (f
);
9061 /* Don't keep the highlight on an invisible frame. */
9062 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9063 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9065 #if 0/* This might add unreliability; I don't trust it -- rms. */
9066 if (! f
->async_visible
&& ! f
->async_iconified
)
9072 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9073 that the current position of the window is user-specified, rather than
9074 program-specified, so that when the window is mapped again, it will be
9075 placed at the same location, without forcing the user to position it
9076 by hand again (they have already done that once for this window.) */
9077 x_wm_set_size_hint (f
, (long) 0, 1);
9080 if (FRAME_GTK_OUTER_WIDGET (f
))
9081 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9087 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9088 DefaultScreen (FRAME_X_DISPLAY (f
))))
9090 UNBLOCK_INPUT_RESIGNAL
;
9091 error ("Can't notify window manager of window withdrawal");
9093 #else /* ! defined (HAVE_X11R4) */
9095 /* Tell the window manager what we're going to do. */
9096 if (! EQ (Vx_no_window_manager
, Qt
))
9100 unmap
.xunmap
.type
= UnmapNotify
;
9101 unmap
.xunmap
.window
= window
;
9102 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
9103 unmap
.xunmap
.from_configure
= False
;
9104 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9105 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9107 SubstructureRedirectMaskSubstructureNotifyMask
,
9110 UNBLOCK_INPUT_RESIGNAL
;
9111 error ("Can't notify window manager of withdrawal");
9115 /* Unmap the window ourselves. Cheeky! */
9116 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
9117 #endif /* ! defined (HAVE_X11R4) */
9120 /* We can't distinguish this from iconification
9121 just by the event that we get from the server.
9122 So we can't win using the usual strategy of letting
9123 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9124 and synchronize with the server to make sure we agree. */
9126 FRAME_ICONIFIED_P (f
) = 0;
9127 f
->async_visible
= 0;
9128 f
->async_iconified
= 0;
9135 /* Change window state from mapped to iconified. */
9144 /* Don't keep the highlight on an invisible frame. */
9145 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9146 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9148 if (f
->async_iconified
)
9153 FRAME_SAMPLE_VISIBILITY (f
);
9155 type
= x_icon_type (f
);
9157 x_bitmap_icon (f
, type
);
9160 if (FRAME_GTK_OUTER_WIDGET (f
))
9162 if (! FRAME_VISIBLE_P (f
))
9163 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9165 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9168 f
->async_iconified
= 1;
9169 f
->async_visible
= 0;
9175 #ifdef USE_X_TOOLKIT
9177 if (! FRAME_VISIBLE_P (f
))
9179 if (! EQ (Vx_no_window_manager
, Qt
))
9180 x_wm_set_window_state (f
, IconicState
);
9181 /* This was XtPopup, but that did nothing for an iconified frame. */
9182 XtMapWidget (f
->output_data
.x
->widget
);
9183 /* The server won't give us any event to indicate
9184 that an invisible frame was changed to an icon,
9185 so we have to record it here. */
9188 f
->async_iconified
= 1;
9189 f
->async_visible
= 0;
9194 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9195 XtWindow (f
->output_data
.x
->widget
),
9196 DefaultScreen (FRAME_X_DISPLAY (f
)));
9200 error ("Can't notify window manager of iconification");
9202 f
->async_iconified
= 1;
9203 f
->async_visible
= 0;
9207 XFlush (FRAME_X_DISPLAY (f
));
9209 #else /* not USE_X_TOOLKIT */
9211 /* Make sure the X server knows where the window should be positioned,
9212 in case the user deiconifies with the window manager. */
9213 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
9214 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9216 /* Since we don't know which revision of X we're running, we'll use both
9217 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9219 /* X11R4: send a ClientMessage to the window manager using the
9220 WM_CHANGE_STATE type. */
9224 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9225 message
.xclient
.type
= ClientMessage
;
9226 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9227 message
.xclient
.format
= 32;
9228 message
.xclient
.data
.l
[0] = IconicState
;
9230 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9231 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9233 SubstructureRedirectMask
| SubstructureNotifyMask
,
9236 UNBLOCK_INPUT_RESIGNAL
;
9237 error ("Can't notify window manager of iconification");
9241 /* X11R3: set the initial_state field of the window manager hints to
9243 x_wm_set_window_state (f
, IconicState
);
9245 if (!FRAME_VISIBLE_P (f
))
9247 /* If the frame was withdrawn, before, we must map it. */
9248 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9251 f
->async_iconified
= 1;
9252 f
->async_visible
= 0;
9254 XFlush (FRAME_X_DISPLAY (f
));
9256 #endif /* not USE_X_TOOLKIT */
9260 /* Free X resources of frame F. */
9263 x_free_frame_resources (f
)
9266 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9268 struct scroll_bar
*b
;
9272 /* If a display connection is dead, don't try sending more
9273 commands to the X server. */
9274 if (dpyinfo
->display
)
9276 if (f
->output_data
.x
->icon_desc
)
9277 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9279 #ifdef USE_X_TOOLKIT
9280 /* Explicitly destroy the scroll bars of the frame. Without
9281 this, we get "BadDrawable" errors from the toolkit later on,
9282 presumably from expose events generated for the disappearing
9283 toolkit scroll bars. */
9284 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9286 b
= XSCROLL_BAR (bar
);
9287 x_scroll_bar_remove (b
);
9296 #ifdef USE_X_TOOLKIT
9297 if (f
->output_data
.x
->widget
)
9299 XtDestroyWidget (f
->output_data
.x
->widget
);
9300 f
->output_data
.x
->widget
= NULL
;
9302 /* Tooltips don't have widgets, only a simple X window, even if
9303 we are using a toolkit. */
9304 else if (FRAME_X_WINDOW (f
))
9305 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9307 free_frame_menubar (f
);
9308 #else /* !USE_X_TOOLKIT */
9311 /* In the GTK version, tooltips are normal X
9312 frames. We must check and free both types. */
9313 if (FRAME_GTK_OUTER_WIDGET (f
))
9315 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
9316 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow below */
9317 FRAME_GTK_OUTER_WIDGET (f
) = 0;
9319 #endif /* USE_GTK */
9321 if (FRAME_X_WINDOW (f
))
9322 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9323 #endif /* !USE_X_TOOLKIT */
9325 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
9326 unload_color (f
, f
->output_data
.x
->background_pixel
);
9327 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9328 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9329 unload_color (f
, f
->output_data
.x
->border_pixel
);
9330 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9332 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9333 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9334 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9335 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9336 #ifdef USE_TOOLKIT_SCROLL_BARS
9337 /* Scrollbar shadow colors. */
9338 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9339 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9340 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9341 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9342 #endif /* USE_TOOLKIT_SCROLL_BARS */
9343 if (f
->output_data
.x
->white_relief
.allocated_p
)
9344 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9345 if (f
->output_data
.x
->black_relief
.allocated_p
)
9346 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9348 if (FRAME_FACE_CACHE (f
))
9349 free_frame_faces (f
);
9352 XFlush (FRAME_X_DISPLAY (f
));
9355 if (f
->output_data
.x
->saved_menu_event
)
9356 xfree (f
->output_data
.x
->saved_menu_event
);
9358 xfree (f
->output_data
.x
);
9359 f
->output_data
.x
= NULL
;
9361 if (f
== dpyinfo
->x_focus_frame
)
9362 dpyinfo
->x_focus_frame
= 0;
9363 if (f
== dpyinfo
->x_focus_event_frame
)
9364 dpyinfo
->x_focus_event_frame
= 0;
9365 if (f
== dpyinfo
->x_highlight_frame
)
9366 dpyinfo
->x_highlight_frame
= 0;
9368 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9370 dpyinfo
->mouse_face_beg_row
9371 = dpyinfo
->mouse_face_beg_col
= -1;
9372 dpyinfo
->mouse_face_end_row
9373 = dpyinfo
->mouse_face_end_col
= -1;
9374 dpyinfo
->mouse_face_window
= Qnil
;
9375 dpyinfo
->mouse_face_deferred_gc
= 0;
9376 dpyinfo
->mouse_face_mouse_frame
= 0;
9383 /* Destroy the X window of frame F. */
9386 x_destroy_window (f
)
9389 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9391 /* If a display connection is dead, don't try sending more
9392 commands to the X server. */
9393 if (dpyinfo
->display
!= 0)
9394 x_free_frame_resources (f
);
9396 dpyinfo
->reference_count
--;
9400 /* Setting window manager hints. */
9402 /* Set the normal size hints for the window manager, for frame F.
9403 FLAGS is the flags word to use--or 0 meaning preserve the flags
9404 that the window now has.
9405 If USER_POSITION is nonzero, we set the USPosition
9406 flag (this is useful when FLAGS is 0).
9407 The GTK version is in gtkutils.c */
9411 x_wm_set_size_hint (f
, flags
, user_position
)
9416 XSizeHints size_hints
;
9418 #ifdef USE_X_TOOLKIT
9421 Dimension widget_width
, widget_height
;
9424 Window window
= FRAME_OUTER_WINDOW (f
);
9426 /* Setting PMaxSize caused various problems. */
9427 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9429 size_hints
.x
= f
->left_pos
;
9430 size_hints
.y
= f
->top_pos
;
9432 #ifdef USE_X_TOOLKIT
9433 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
9434 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
9435 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
9436 size_hints
.height
= widget_height
;
9437 size_hints
.width
= widget_width
;
9438 #else /* not USE_X_TOOLKIT */
9439 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9440 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9441 #endif /* not USE_X_TOOLKIT */
9443 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9444 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9445 size_hints
.max_width
9446 = FRAME_X_DISPLAY_INFO (f
)->width
- FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9447 size_hints
.max_height
9448 = FRAME_X_DISPLAY_INFO (f
)->height
- FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9450 /* Calculate the base and minimum sizes.
9452 (When we use the X toolkit, we don't do it here.
9453 Instead we copy the values that the widgets are using, below.) */
9454 #ifndef USE_X_TOOLKIT
9456 int base_width
, base_height
;
9457 int min_rows
= 0, min_cols
= 0;
9459 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9460 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9462 check_frame_size (f
, &min_rows
, &min_cols
);
9464 /* The window manager uses the base width hints to calculate the
9465 current number of rows and columns in the frame while
9466 resizing; min_width and min_height aren't useful for this
9467 purpose, since they might not give the dimensions for a
9468 zero-row, zero-column frame.
9470 We use the base_width and base_height members if we have
9471 them; otherwise, we set the min_width and min_height members
9472 to the size for a zero x zero frame. */
9475 size_hints
.flags
|= PBaseSize
;
9476 size_hints
.base_width
= base_width
;
9477 size_hints
.base_height
= base_height
;
9478 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9479 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9481 size_hints
.min_width
= base_width
;
9482 size_hints
.min_height
= base_height
;
9486 /* If we don't need the old flags, we don't need the old hint at all. */
9489 size_hints
.flags
|= flags
;
9492 #endif /* not USE_X_TOOLKIT */
9495 XSizeHints hints
; /* Sometimes I hate X Windows... */
9496 long supplied_return
;
9500 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9503 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
9506 #ifdef USE_X_TOOLKIT
9507 size_hints
.base_height
= hints
.base_height
;
9508 size_hints
.base_width
= hints
.base_width
;
9509 size_hints
.min_height
= hints
.min_height
;
9510 size_hints
.min_width
= hints
.min_width
;
9514 size_hints
.flags
|= flags
;
9519 if (hints
.flags
& PSize
)
9520 size_hints
.flags
|= PSize
;
9521 if (hints
.flags
& PPosition
)
9522 size_hints
.flags
|= PPosition
;
9523 if (hints
.flags
& USPosition
)
9524 size_hints
.flags
|= USPosition
;
9525 if (hints
.flags
& USSize
)
9526 size_hints
.flags
|= USSize
;
9530 #ifndef USE_X_TOOLKIT
9535 size_hints
.win_gravity
= f
->win_gravity
;
9536 size_hints
.flags
|= PWinGravity
;
9540 size_hints
.flags
&= ~ PPosition
;
9541 size_hints
.flags
|= USPosition
;
9543 #endif /* PWinGravity */
9546 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9548 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9551 #endif /* not USE_GTK */
9553 /* Used for IconicState or NormalState */
9556 x_wm_set_window_state (f
, state
)
9560 #ifdef USE_X_TOOLKIT
9563 XtSetArg (al
[0], XtNinitialState
, state
);
9564 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9565 #else /* not USE_X_TOOLKIT */
9566 Window window
= FRAME_X_WINDOW (f
);
9568 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9569 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9571 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9572 #endif /* not USE_X_TOOLKIT */
9576 x_wm_set_icon_pixmap (f
, pixmap_id
)
9580 Pixmap icon_pixmap
, icon_mask
;
9582 #ifndef USE_X_TOOLKIT
9583 Window window
= FRAME_OUTER_WINDOW (f
);
9588 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9589 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9590 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9591 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9595 /* It seems there is no way to turn off use of an icon pixmap.
9596 The following line does it, only if no icon has yet been created,
9597 for some window managers. But with mwm it crashes.
9598 Some people say it should clear the IconPixmapHint bit in this case,
9599 but that doesn't work, and the X consortium said it isn't the
9600 right thing at all. Since there is no way to win,
9601 best to explicitly give up. */
9603 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
9604 f
->output_data
.x
->wm_hints
.icon_mask
= None
;
9613 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9617 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9621 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9622 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9623 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9624 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9627 #else /* not USE_X_TOOLKIT && not USE_GTK */
9629 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9630 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9632 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9636 x_wm_set_icon_position (f
, icon_x
, icon_y
)
9640 Window window
= FRAME_OUTER_WINDOW (f
);
9642 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9643 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9644 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9646 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9650 /***********************************************************************
9652 ***********************************************************************/
9654 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
9657 x_get_font_info (f
, font_idx
)
9661 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
9665 /* Return a list of names of available fonts matching PATTERN on frame F.
9667 If SIZE is > 0, it is the size (maximum bounds width) of fonts
9670 SIZE < 0 means include scalable fonts.
9672 Frame F null means we have not yet created any frame on X, and
9673 consult the first display in x_display_list. MAXNAMES sets a limit
9674 on how many fonts to match. */
9677 x_list_fonts (f
, pattern
, size
, maxnames
)
9679 Lisp_Object pattern
;
9683 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
9684 Lisp_Object tem
, second_best
;
9685 struct x_display_info
*dpyinfo
9686 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
9687 Display
*dpy
= dpyinfo
->display
;
9688 int try_XLoadQueryFont
= 0;
9689 int allow_auto_scaled_font
= 0;
9693 allow_auto_scaled_font
= 1;
9697 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
9698 if (NILP (patterns
))
9699 patterns
= Fcons (pattern
, Qnil
);
9701 if (maxnames
== 1 && !size
)
9702 /* We can return any single font matching PATTERN. */
9703 try_XLoadQueryFont
= 1;
9705 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
9708 char **names
= NULL
;
9710 pattern
= XCAR (patterns
);
9711 /* See if we cached the result for this particular query.
9712 The cache is an alist of the form:
9713 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
9714 tem
= XCDR (dpyinfo
->name_list_element
);
9715 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
9716 allow_auto_scaled_font
? Qt
: Qnil
);
9717 list
= Fassoc (key
, tem
);
9720 list
= Fcdr_safe (list
);
9721 /* We have a cashed list. Don't have to get the list again. */
9725 /* At first, put PATTERN in the cache. */
9728 x_catch_errors (dpy
);
9730 if (try_XLoadQueryFont
)
9733 unsigned long value
;
9735 font
= XLoadQueryFont (dpy
, SDATA (pattern
));
9736 if (x_had_errors_p (dpy
))
9738 /* This error is perhaps due to insufficient memory on X
9739 server. Let's just ignore it. */
9741 x_clear_errors (dpy
);
9745 && XGetFontProperty (font
, XA_FONT
, &value
))
9747 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
9748 int len
= strlen (name
);
9751 /* If DXPC (a Differential X Protocol Compressor)
9752 Ver.3.7 is running, XGetAtomName will return null
9753 string. We must avoid such a name. */
9755 try_XLoadQueryFont
= 0;
9759 names
= (char **) alloca (sizeof (char *));
9760 /* Some systems only allow alloca assigned to a
9762 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
9763 bcopy (name
, names
[0], len
+ 1);
9768 try_XLoadQueryFont
= 0;
9771 XFreeFont (dpy
, font
);
9774 if (!try_XLoadQueryFont
)
9776 /* We try at least 10 fonts because XListFonts will return
9777 auto-scaled fonts at the head. */
9784 names
= XListFonts (dpy
, SDATA (pattern
), limit
, &num_fonts
);
9785 if (num_fonts
== limit
)
9788 XFreeFontNames (names
);
9797 names
= XListFonts (dpy
, SDATA (pattern
), max (maxnames
, 10),
9800 if (x_had_errors_p (dpy
))
9802 /* This error is perhaps due to insufficient memory on X
9803 server. Let's just ignore it. */
9805 x_clear_errors (dpy
);
9809 x_uncatch_errors ();
9816 /* Make a list of all the fonts we got back.
9817 Store that in the font cache for the display. */
9818 for (i
= 0; i
< num_fonts
; i
++)
9822 int average_width
= -1, resx
= 0, dashes
= 0;
9824 /* Count the number of dashes in NAMES[I]. If there are
9825 14 dashes, the field value following 9th dash
9826 (RESOLUTION_X) is nonzero, and the field value
9827 following 12th dash (AVERAGE_WIDTH) is 0, this is a
9828 auto-scaled font which is usually too ugly to be used
9829 for editing. Let's ignore it. */
9834 if (dashes
== 7) /* PIXEL_SIZE field */
9836 else if (dashes
== 9)
9838 else if (dashes
== 12) /* AVERAGE_WIDTH field */
9839 average_width
= atoi (p
);
9842 if (allow_auto_scaled_font
9843 || dashes
< 14 || average_width
!= 0 || resx
== 0)
9845 tem
= build_string (names
[i
]);
9846 if (NILP (Fassoc (tem
, list
)))
9848 if (STRINGP (Vx_pixel_size_width_font_regexp
)
9849 && ((fast_c_string_match_ignore_case
9850 (Vx_pixel_size_width_font_regexp
, names
[i
]))
9852 /* We can set the value of PIXEL_SIZE to the
9853 width of this font. */
9854 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
9856 /* For the moment, width is not known. */
9857 list
= Fcons (Fcons (tem
, Qnil
), list
);
9862 if (!try_XLoadQueryFont
)
9865 XFreeFontNames (names
);
9870 /* Now store the result in the cache. */
9871 XSETCDR (dpyinfo
->name_list_element
,
9872 Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
)));
9875 if (NILP (list
)) continue; /* Try the remaining alternatives. */
9877 newlist
= second_best
= Qnil
;
9878 /* Make a list of the fonts that have the right width. */
9879 for (; CONSP (list
); list
= XCDR (list
))
9885 if (!CONSP (tem
) || NILP (XCAR (tem
)))
9889 newlist
= Fcons (XCAR (tem
), newlist
);
9893 if (!INTEGERP (XCDR (tem
)))
9895 /* Since we have not yet known the size of this font, we
9896 must try slow function call XLoadQueryFont. */
9897 XFontStruct
*thisinfo
;
9900 x_catch_errors (dpy
);
9901 thisinfo
= XLoadQueryFont (dpy
,
9902 SDATA (XCAR (tem
)));
9903 if (x_had_errors_p (dpy
))
9905 /* This error is perhaps due to insufficient memory on X
9906 server. Let's just ignore it. */
9908 x_clear_errors (dpy
);
9910 x_uncatch_errors ();
9916 (thisinfo
->min_bounds
.width
== 0
9918 : make_number (thisinfo
->max_bounds
.width
)));
9920 XFreeFont (dpy
, thisinfo
);
9924 /* For unknown reason, the previous call of XListFont had
9925 returned a font which can't be opened. Record the size
9926 as 0 not to try to open it again. */
9927 XSETCDR (tem
, make_number (0));
9930 found_size
= XINT (XCDR (tem
));
9931 if (found_size
== size
)
9932 newlist
= Fcons (XCAR (tem
), newlist
);
9933 else if (found_size
> 0)
9935 if (NILP (second_best
))
9937 else if (found_size
< size
)
9939 if (XINT (XCDR (second_best
)) > size
9940 || XINT (XCDR (second_best
)) < found_size
)
9945 if (XINT (XCDR (second_best
)) > size
9946 && XINT (XCDR (second_best
)) > found_size
)
9951 if (!NILP (newlist
))
9953 else if (!NILP (second_best
))
9955 newlist
= Fcons (XCAR (second_best
), Qnil
);
9966 /* Check that FONT is valid on frame F. It is if it can be found in F's
9970 x_check_font (f
, font
)
9975 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9977 xassert (font
!= NULL
);
9979 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9980 if (dpyinfo
->font_table
[i
].name
9981 && font
== dpyinfo
->font_table
[i
].font
)
9984 xassert (i
< dpyinfo
->n_fonts
);
9987 #endif /* GLYPH_DEBUG != 0 */
9989 /* Set *W to the minimum width, *H to the minimum font height of FONT.
9990 Note: There are (broken) X fonts out there with invalid XFontStruct
9991 min_bounds contents. For example, handa@etl.go.jp reports that
9992 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
9993 have font->min_bounds.width == 0. */
9996 x_font_min_bounds (font
, w
, h
)
10000 *h
= FONT_HEIGHT (font
);
10001 *w
= font
->min_bounds
.width
;
10003 /* Try to handle the case where FONT->min_bounds has invalid
10004 contents. Since the only font known to have invalid min_bounds
10005 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
10007 *w
= font
->max_bounds
.width
;
10011 /* Compute the smallest character width and smallest font height over
10012 all fonts available on frame F. Set the members smallest_char_width
10013 and smallest_font_height in F's x_display_info structure to
10014 the values computed. Value is non-zero if smallest_font_height or
10015 smallest_char_width become smaller than they were before. */
10018 x_compute_min_glyph_bounds (f
)
10022 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10024 int old_width
= dpyinfo
->smallest_char_width
;
10025 int old_height
= dpyinfo
->smallest_font_height
;
10027 dpyinfo
->smallest_font_height
= 100000;
10028 dpyinfo
->smallest_char_width
= 100000;
10030 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
10031 if (dpyinfo
->font_table
[i
].name
)
10033 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
10036 font
= (XFontStruct
*) fontp
->font
;
10037 xassert (font
!= (XFontStruct
*) ~0);
10038 x_font_min_bounds (font
, &w
, &h
);
10040 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
10041 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
10044 xassert (dpyinfo
->smallest_char_width
> 0
10045 && dpyinfo
->smallest_font_height
> 0);
10047 return (dpyinfo
->n_fonts
== 1
10048 || dpyinfo
->smallest_char_width
< old_width
10049 || dpyinfo
->smallest_font_height
< old_height
);
10053 /* Load font named FONTNAME of the size SIZE for frame F, and return a
10054 pointer to the structure font_info while allocating it dynamically.
10055 If SIZE is 0, load any size of font.
10056 If loading is failed, return NULL. */
10059 x_load_font (f
, fontname
, size
)
10061 register char *fontname
;
10064 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10065 Lisp_Object font_names
;
10067 /* Get a list of all the fonts that match this name. Once we
10068 have a list of matching fonts, we compare them against the fonts
10069 we already have by comparing names. */
10070 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
10072 if (!NILP (font_names
))
10077 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10078 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
10079 if (dpyinfo
->font_table
[i
].name
10080 && (!strcmp (dpyinfo
->font_table
[i
].name
,
10081 SDATA (XCAR (tail
)))
10082 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
10083 SDATA (XCAR (tail
)))))
10084 return (dpyinfo
->font_table
+ i
);
10087 /* Load the font and add it to the table. */
10091 struct font_info
*fontp
;
10092 unsigned long value
;
10095 /* If we have found fonts by x_list_font, load one of them. If
10096 not, we still try to load a font by the name given as FONTNAME
10097 because XListFonts (called in x_list_font) of some X server has
10098 a bug of not finding a font even if the font surely exists and
10099 is loadable by XLoadQueryFont. */
10100 if (size
> 0 && !NILP (font_names
))
10101 fontname
= (char *) SDATA (XCAR (font_names
));
10104 x_catch_errors (FRAME_X_DISPLAY (f
));
10105 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
10106 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
10108 /* This error is perhaps due to insufficient memory on X
10109 server. Let's just ignore it. */
10111 x_clear_errors (FRAME_X_DISPLAY (f
));
10113 x_uncatch_errors ();
10118 /* Find a free slot in the font table. */
10119 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
10120 if (dpyinfo
->font_table
[i
].name
== NULL
)
10123 /* If no free slot found, maybe enlarge the font table. */
10124 if (i
== dpyinfo
->n_fonts
10125 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
10128 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
10129 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
10130 dpyinfo
->font_table
10131 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
10134 fontp
= dpyinfo
->font_table
+ i
;
10135 if (i
== dpyinfo
->n_fonts
)
10136 ++dpyinfo
->n_fonts
;
10138 /* Now fill in the slots of *FONTP. */
10140 bzero (fontp
, sizeof (*fontp
));
10141 fontp
->font
= font
;
10142 fontp
->font_idx
= i
;
10143 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
10144 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
10146 if (font
->min_bounds
.width
== font
->max_bounds
.width
)
10148 /* Fixed width font. */
10149 fontp
->average_width
= fontp
->space_width
= font
->min_bounds
.width
;
10156 char2b
.byte1
= 0x00, char2b
.byte2
= 0x20;
10157 pcm
= x_per_char_metric (font
, &char2b
, 0);
10159 fontp
->space_width
= pcm
->width
;
10161 fontp
->space_width
= FONT_WIDTH (font
);
10163 fontp
->average_width
10164 = (XGetFontProperty (font
, dpyinfo
->Xatom_AVERAGE_WIDTH
, &value
)
10165 ? (long) value
/ 10 : 0);
10166 if (fontp
->average_width
< 0)
10167 fontp
->average_width
= - fontp
->average_width
;
10168 if (fontp
->average_width
== 0)
10172 int width
= pcm
->width
;
10173 for (char2b
.byte2
= 33; char2b
.byte2
<= 126; char2b
.byte2
++)
10174 if ((pcm
= x_per_char_metric (font
, &char2b
, 0)) != NULL
)
10175 width
+= pcm
->width
;
10176 fontp
->average_width
= width
/ 95;
10179 fontp
->average_width
= FONT_WIDTH (font
);
10183 /* Try to get the full name of FONT. Put it in FULL_NAME. */
10185 if (XGetFontProperty (font
, XA_FONT
, &value
))
10187 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
10191 /* Count the number of dashes in the "full name".
10192 If it is too few, this isn't really the font's full name,
10194 In X11R4, the fonts did not come with their canonical names
10205 full_name
= (char *) xmalloc (p
- name
+ 1);
10206 bcopy (name
, full_name
, p
- name
+ 1);
10212 if (full_name
!= 0)
10213 fontp
->full_name
= full_name
;
10215 fontp
->full_name
= fontp
->name
;
10217 fontp
->size
= font
->max_bounds
.width
;
10218 fontp
->height
= FONT_HEIGHT (font
);
10220 if (NILP (font_names
))
10222 /* We come here because of a bug of XListFonts mentioned at
10223 the head of this block. Let's store this information in
10224 the cache for x_list_fonts. */
10225 Lisp_Object lispy_name
= build_string (fontname
);
10226 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
10227 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
10230 XSETCDR (dpyinfo
->name_list_element
,
10232 Fcons (Fcons (lispy_full_name
,
10233 make_number (fontp
->size
)),
10235 XCDR (dpyinfo
->name_list_element
)));
10238 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
10240 XSETCDR (dpyinfo
->name_list_element
,
10242 Fcons (Fcons (lispy_full_name
,
10243 make_number (fontp
->size
)),
10245 XCDR (dpyinfo
->name_list_element
)));
10249 /* The slot `encoding' specifies how to map a character
10250 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
10251 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
10252 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
10253 2:0xA020..0xFF7F). For the moment, we don't know which charset
10254 uses this font. So, we set information in fontp->encoding[1]
10255 which is never used by any charset. If mapping can't be
10256 decided, set FONT_ENCODING_NOT_DECIDED. */
10258 = (font
->max_byte1
== 0
10260 ? (font
->min_char_or_byte2
< 0x80
10261 ? (font
->max_char_or_byte2
< 0x80
10262 ? 0 /* 0x20..0x7F */
10263 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
10264 : 1) /* 0xA0..0xFF */
10266 : (font
->min_byte1
< 0x80
10267 ? (font
->max_byte1
< 0x80
10268 ? (font
->min_char_or_byte2
< 0x80
10269 ? (font
->max_char_or_byte2
< 0x80
10270 ? 0 /* 0x2020..0x7F7F */
10271 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
10272 : 3) /* 0x20A0..0x7FFF */
10273 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
10274 : (font
->min_char_or_byte2
< 0x80
10275 ? (font
->max_char_or_byte2
< 0x80
10276 ? 2 /* 0xA020..0xFF7F */
10277 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
10278 : 1))); /* 0xA0A0..0xFFFF */
10280 fontp
->baseline_offset
10281 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
10282 ? (long) value
: 0);
10283 fontp
->relative_compose
10284 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
10285 ? (long) value
: 0);
10286 fontp
->default_ascent
10287 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
10288 ? (long) value
: 0);
10290 /* Set global flag fonts_changed_p to non-zero if the font loaded
10291 has a character with a smaller width than any other character
10292 before, or if the font loaded has a smaller height than any
10293 other font loaded before. If this happens, it will make a
10294 glyph matrix reallocation necessary. */
10295 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
10302 /* Return a pointer to struct font_info of a font named FONTNAME for
10303 frame F. If no such font is loaded, return NULL. */
10306 x_query_font (f
, fontname
)
10308 register char *fontname
;
10310 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10313 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10314 if (dpyinfo
->font_table
[i
].name
10315 && (!xstricmp (dpyinfo
->font_table
[i
].name
, fontname
)
10316 || !xstricmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
10317 return (dpyinfo
->font_table
+ i
);
10322 /* Find a CCL program for a font specified by FONTP, and set the member
10323 `encoder' of the structure. */
10326 x_find_ccl_program (fontp
)
10327 struct font_info
*fontp
;
10329 Lisp_Object list
, elt
;
10332 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
10336 && STRINGP (XCAR (elt
))
10337 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
10339 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
10346 struct ccl_program
*ccl
10347 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
10349 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
10352 fontp
->font_encoder
= ccl
;
10358 /***********************************************************************
10360 ***********************************************************************/
10362 #ifdef USE_X_TOOLKIT
10363 static XrmOptionDescRec emacs_options
[] = {
10364 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
10365 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
10367 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10368 XrmoptionSepArg
, NULL
},
10369 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
10371 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10372 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10373 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10374 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10375 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10376 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
10377 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
10380 /* Whether atimer for Xt timeouts is activated or not. */
10382 static int x_timeout_atimer_activated_flag
;
10384 #endif /* USE_X_TOOLKIT */
10386 static int x_initialized
;
10389 static int x_session_initialized
;
10392 #ifdef MULTI_KBOARD
10393 /* Test whether two display-name strings agree up to the dot that separates
10394 the screen number from the server number. */
10396 same_x_server (name1
, name2
)
10397 const char *name1
, *name2
;
10399 int seen_colon
= 0;
10400 const unsigned char *system_name
= SDATA (Vsystem_name
);
10401 int system_name_length
= strlen (system_name
);
10402 int length_until_period
= 0;
10404 while (system_name
[length_until_period
] != 0
10405 && system_name
[length_until_period
] != '.')
10406 length_until_period
++;
10408 /* Treat `unix' like an empty host name. */
10409 if (! strncmp (name1
, "unix:", 5))
10411 if (! strncmp (name2
, "unix:", 5))
10413 /* Treat this host's name like an empty host name. */
10414 if (! strncmp (name1
, system_name
, system_name_length
)
10415 && name1
[system_name_length
] == ':')
10416 name1
+= system_name_length
;
10417 if (! strncmp (name2
, system_name
, system_name_length
)
10418 && name2
[system_name_length
] == ':')
10419 name2
+= system_name_length
;
10420 /* Treat this host's domainless name like an empty host name. */
10421 if (! strncmp (name1
, system_name
, length_until_period
)
10422 && name1
[length_until_period
] == ':')
10423 name1
+= length_until_period
;
10424 if (! strncmp (name2
, system_name
, length_until_period
)
10425 && name2
[length_until_period
] == ':')
10426 name2
+= length_until_period
;
10428 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
10432 if (seen_colon
&& *name1
== '.')
10436 && (*name1
== '.' || *name1
== '\0')
10437 && (*name2
== '.' || *name2
== '\0'));
10441 /* Count number of set bits in mask and number of bits to shift to
10442 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
10445 get_bits_and_offset (mask
, bits
, offset
)
10446 unsigned long mask
;
10453 while (!(mask
& 1))
10470 x_display_ok (display
)
10471 const char * display
;
10476 dpy
= XOpenDisplay (display
);
10478 XCloseDisplay (dpy
);
10484 struct x_display_info
*
10485 x_term_init (display_name
, xrm_option
, resource_name
)
10486 Lisp_Object display_name
;
10488 char *resource_name
;
10492 struct x_display_info
*dpyinfo
;
10497 if (!x_initialized
)
10505 #define NUM_ARGV 10
10507 char *argv
[NUM_ARGV
];
10508 char **argv2
= argv
;
10511 if (x_initialized
++ > 1)
10513 /* Opening another display. If xg_display_open returns less
10514 than zero, we are probably on GTK 2.0, which can only handle
10515 one display. GTK 2.2 or later can handle more than one. */
10516 if (xg_display_open (SDATA (display_name
), &dpy
) < 0)
10517 error ("Sorry, this version of GTK can only handle one display");
10521 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
10525 argv
[argc
++] = initial_argv
[0];
10527 if (! NILP (display_name
))
10529 argv
[argc
++] = "--display";
10530 argv
[argc
++] = SDATA (display_name
);
10533 argv
[argc
++] = "--name";
10534 argv
[argc
++] = resource_name
;
10537 XSetLocaleModifiers ("");
10540 gtk_init (&argc
, &argv2
);
10542 /* gtk_init does set_locale. We must fix locale after calling it. */
10546 dpy
= GDK_DISPLAY ();
10548 /* NULL window -> events for all windows go to our function */
10549 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
10551 /* Load our own gtkrc if it exists. */
10553 char *file
= "~/.emacs.d/gtkrc";
10554 Lisp_Object s
, abs_file
;
10556 s
= make_string (file
, strlen (file
));
10557 abs_file
= Fexpand_file_name (s
, Qnil
);
10559 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
10560 gtk_rc_parse (SDATA (abs_file
));
10563 XSetErrorHandler (x_error_handler
);
10564 XSetIOErrorHandler (x_io_error_quitter
);
10567 #else /* not USE_GTK */
10568 #ifdef USE_X_TOOLKIT
10569 /* weiner@footloose.sps.mot.com reports that this causes
10571 X protocol error: BadAtom (invalid Atom parameter)
10572 on protocol request 18skiloaf.
10573 So let's not use it until R6. */
10574 #ifdef HAVE_X11XTR6
10575 XtSetLanguageProc (NULL
, NULL
, NULL
);
10586 argv
[argc
++] = "-xrm";
10587 argv
[argc
++] = xrm_option
;
10589 turn_on_atimers (0);
10590 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
10591 resource_name
, EMACS_CLASS
,
10592 emacs_options
, XtNumber (emacs_options
),
10594 turn_on_atimers (1);
10596 #ifdef HAVE_X11XTR6
10597 /* I think this is to compensate for XtSetLanguageProc. */
10602 #else /* not USE_X_TOOLKIT */
10604 XSetLocaleModifiers ("");
10606 dpy
= XOpenDisplay (SDATA (display_name
));
10607 #endif /* not USE_X_TOOLKIT */
10608 #endif /* not USE_GTK*/
10610 /* Detect failure. */
10617 /* We have definitely succeeded. Record the new connection. */
10619 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
10620 bzero (dpyinfo
, sizeof *dpyinfo
);
10622 #ifdef MULTI_KBOARD
10624 struct x_display_info
*share
;
10627 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
10628 share
= share
->next
, tail
= XCDR (tail
))
10629 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
10630 SDATA (display_name
)))
10633 dpyinfo
->kboard
= share
->kboard
;
10636 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
10637 init_kboard (dpyinfo
->kboard
);
10638 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
10640 char *vendor
= ServerVendor (dpy
);
10642 dpyinfo
->kboard
->Vsystem_key_alist
10643 = call1 (Qvendor_specific_keysyms
,
10644 build_string (vendor
? vendor
: ""));
10648 dpyinfo
->kboard
->next_kboard
= all_kboards
;
10649 all_kboards
= dpyinfo
->kboard
;
10650 /* Don't let the initial kboard remain current longer than necessary.
10651 That would cause problems if a file loaded on startup tries to
10652 prompt in the mini-buffer. */
10653 if (current_kboard
== initial_kboard
)
10654 current_kboard
= dpyinfo
->kboard
;
10656 dpyinfo
->kboard
->reference_count
++;
10660 /* Put this display on the chain. */
10661 dpyinfo
->next
= x_display_list
;
10662 x_display_list
= dpyinfo
;
10664 /* Put it on x_display_name_list as well, to keep them parallel. */
10665 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
10666 x_display_name_list
);
10667 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
10669 dpyinfo
->display
= dpy
;
10672 XSetAfterFunction (x_current_display
, x_trace_wire
);
10676 = (char *) xmalloc (SBYTES (Vinvocation_name
)
10677 + SBYTES (Vsystem_name
)
10679 sprintf (dpyinfo
->x_id_name
, "%s@%s",
10680 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10682 /* Figure out which modifier bits mean what. */
10683 x_find_modifier_meanings (dpyinfo
);
10685 /* Get the scroll bar cursor. */
10687 /* We must create a GTK cursor, it is required for GTK widgets. */
10688 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10689 #endif /* USE_GTK */
10691 dpyinfo
->vertical_scroll_bar_cursor
10692 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10694 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10695 resource_name
, EMACS_CLASS
);
10696 #ifdef HAVE_XRMSETDATABASE
10697 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10699 dpyinfo
->display
->db
= xrdb
;
10701 /* Put the rdb where we can find it in a way that works on
10703 dpyinfo
->xrdb
= xrdb
;
10705 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10706 DefaultScreen (dpyinfo
->display
));
10707 select_visual (dpyinfo
);
10708 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10709 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
10710 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
10711 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10712 dpyinfo
->client_leader_window
= 0;
10713 dpyinfo
->grabbed
= 0;
10714 dpyinfo
->reference_count
= 0;
10715 dpyinfo
->icon_bitmap_id
= -1;
10716 dpyinfo
->font_table
= NULL
;
10717 dpyinfo
->n_fonts
= 0;
10718 dpyinfo
->font_table_size
= 0;
10719 dpyinfo
->bitmaps
= 0;
10720 dpyinfo
->bitmaps_size
= 0;
10721 dpyinfo
->bitmaps_last
= 0;
10722 dpyinfo
->scratch_cursor_gc
= 0;
10723 dpyinfo
->mouse_face_mouse_frame
= 0;
10724 dpyinfo
->mouse_face_deferred_gc
= 0;
10725 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10726 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10727 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10728 dpyinfo
->mouse_face_window
= Qnil
;
10729 dpyinfo
->mouse_face_overlay
= Qnil
;
10730 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10731 dpyinfo
->mouse_face_defer
= 0;
10732 dpyinfo
->mouse_face_hidden
= 0;
10733 dpyinfo
->x_focus_frame
= 0;
10734 dpyinfo
->x_focus_event_frame
= 0;
10735 dpyinfo
->x_highlight_frame
= 0;
10736 dpyinfo
->image_cache
= make_image_cache ();
10737 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10739 /* See if we can construct pixel values from RGB values. */
10740 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10741 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10743 if (dpyinfo
->visual
->class == TrueColor
)
10745 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10746 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10747 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10748 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10749 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10750 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10753 /* See if a private colormap is requested. */
10754 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10756 if (dpyinfo
->visual
->class == PseudoColor
)
10759 value
= display_x_get_resource (dpyinfo
,
10760 build_string ("privateColormap"),
10761 build_string ("PrivateColormap"),
10763 if (STRINGP (value
)
10764 && (!strcmp (SDATA (value
), "true")
10765 || !strcmp (SDATA (value
), "on")))
10766 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10770 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10771 dpyinfo
->visual
, AllocNone
);
10774 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10775 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10776 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10777 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10778 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10779 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10780 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10781 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10782 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10785 dpyinfo
->Xatom_wm_protocols
10786 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10787 dpyinfo
->Xatom_wm_take_focus
10788 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10789 dpyinfo
->Xatom_wm_save_yourself
10790 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10791 dpyinfo
->Xatom_wm_delete_window
10792 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10793 dpyinfo
->Xatom_wm_change_state
10794 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10795 dpyinfo
->Xatom_wm_configure_denied
10796 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10797 dpyinfo
->Xatom_wm_window_moved
10798 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10799 dpyinfo
->Xatom_wm_client_leader
10800 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10801 dpyinfo
->Xatom_editres
10802 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10803 dpyinfo
->Xatom_CLIPBOARD
10804 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10805 dpyinfo
->Xatom_TIMESTAMP
10806 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10807 dpyinfo
->Xatom_TEXT
10808 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10809 dpyinfo
->Xatom_COMPOUND_TEXT
10810 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10811 dpyinfo
->Xatom_UTF8_STRING
10812 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10813 dpyinfo
->Xatom_DELETE
10814 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10815 dpyinfo
->Xatom_MULTIPLE
10816 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10817 dpyinfo
->Xatom_INCR
10818 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10819 dpyinfo
->Xatom_EMACS_TMP
10820 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10821 dpyinfo
->Xatom_TARGETS
10822 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10823 dpyinfo
->Xatom_NULL
10824 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10825 dpyinfo
->Xatom_ATOM_PAIR
10826 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10827 /* For properties of font. */
10828 dpyinfo
->Xatom_PIXEL_SIZE
10829 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10830 dpyinfo
->Xatom_AVERAGE_WIDTH
10831 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10832 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10833 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10834 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10835 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10836 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10837 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10839 /* Ghostscript support. */
10840 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10841 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10843 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10846 dpyinfo
->cut_buffers_initialized
= 0;
10848 dpyinfo
->x_dnd_atoms_size
= 8;
10849 dpyinfo
->x_dnd_atoms_length
= 0;
10850 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10851 * dpyinfo
->x_dnd_atoms_size
);
10853 dpyinfo
->net_supported_atoms
= NULL
;
10854 dpyinfo
->nr_net_supported_atoms
= 0;
10855 dpyinfo
->net_supported_window
= 0;
10857 connection
= ConnectionNumber (dpyinfo
->display
);
10858 dpyinfo
->connection
= connection
;
10863 null_bits
[0] = 0x00;
10865 dpyinfo
->null_pixel
10866 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10867 null_bits
, 1, 1, (long) 0, (long) 0,
10872 extern int gray_bitmap_width
, gray_bitmap_height
;
10873 extern char *gray_bitmap_bits
;
10875 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10877 gray_bitmap_width
, gray_bitmap_height
,
10878 (unsigned long) 1, (unsigned long) 0, 1);
10882 xim_initialize (dpyinfo
, resource_name
);
10885 #ifdef subprocesses
10886 /* This is only needed for distinguishing keyboard and process input. */
10887 if (connection
!= 0)
10888 add_keyboard_wait_descriptor (connection
);
10891 #ifndef F_SETOWN_BUG
10893 #ifdef F_SETOWN_SOCK_NEG
10894 /* stdin is a socket here */
10895 fcntl (connection
, F_SETOWN
, -getpid ());
10896 #else /* ! defined (F_SETOWN_SOCK_NEG) */
10897 fcntl (connection
, F_SETOWN
, getpid ());
10898 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
10899 #endif /* ! defined (F_SETOWN) */
10900 #endif /* F_SETOWN_BUG */
10903 if (interrupt_input
)
10904 init_sigio (connection
);
10905 #endif /* ! defined (SIGIO) */
10908 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
10909 /* Make sure that we have a valid font for dialog boxes
10910 so that Xt does not crash. */
10912 Display
*dpy
= dpyinfo
->display
;
10913 XrmValue d
, fr
, to
;
10916 d
.addr
= (XPointer
)&dpy
;
10917 d
.size
= sizeof (Display
*);
10918 fr
.addr
= XtDefaultFont
;
10919 fr
.size
= sizeof (XtDefaultFont
);
10920 to
.size
= sizeof (Font
*);
10921 to
.addr
= (XPointer
)&font
;
10922 x_catch_errors (dpy
);
10923 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10925 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10926 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10927 x_uncatch_errors ();
10932 /* See if we should run in synchronous mode. This is useful
10933 for debugging X code. */
10936 value
= display_x_get_resource (dpyinfo
,
10937 build_string ("synchronous"),
10938 build_string ("Synchronous"),
10940 if (STRINGP (value
)
10941 && (!strcmp (SDATA (value
), "true")
10942 || !strcmp (SDATA (value
), "on")))
10943 XSynchronize (dpyinfo
->display
, True
);
10948 value
= display_x_get_resource (dpyinfo
,
10949 build_string ("useXIM"),
10950 build_string ("UseXIM"),
10953 if (STRINGP (value
)
10954 && (!strcmp (XSTRING (value
)->data
, "false")
10955 || !strcmp (XSTRING (value
)->data
, "off")))
10958 if (STRINGP (value
)
10959 && (!strcmp (XSTRING (value
)->data
, "true")
10960 || !strcmp (XSTRING (value
)->data
, "on")))
10966 /* Only do this for the first display. */
10967 if (!x_session_initialized
++)
10968 x_session_initialize (dpyinfo
);
10976 /* Get rid of display DPYINFO, assuming all frames are already gone,
10977 and without sending any more commands to the X server. */
10980 x_delete_display (dpyinfo
)
10981 struct x_display_info
*dpyinfo
;
10985 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10987 /* Discard this display from x_display_name_list and x_display_list.
10988 We can't use Fdelq because that can quit. */
10989 if (! NILP (x_display_name_list
)
10990 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10991 x_display_name_list
= XCDR (x_display_name_list
);
10996 tail
= x_display_name_list
;
10997 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10999 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
11001 XSETCDR (tail
, XCDR (XCDR (tail
)));
11004 tail
= XCDR (tail
);
11008 if (next_noop_dpyinfo
== dpyinfo
)
11009 next_noop_dpyinfo
= dpyinfo
->next
;
11011 if (x_display_list
== dpyinfo
)
11012 x_display_list
= dpyinfo
->next
;
11015 struct x_display_info
*tail
;
11017 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
11018 if (tail
->next
== dpyinfo
)
11019 tail
->next
= tail
->next
->next
;
11022 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
11023 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
11024 XrmDestroyDatabase (dpyinfo
->xrdb
);
11027 #ifdef MULTI_KBOARD
11028 if (--dpyinfo
->kboard
->reference_count
== 0)
11029 delete_kboard (dpyinfo
->kboard
);
11033 xim_close_dpy (dpyinfo
);
11036 /* Free the font names in the font table. */
11037 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
11038 if (dpyinfo
->font_table
[i
].name
)
11040 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
11041 xfree (dpyinfo
->font_table
[i
].full_name
);
11042 xfree (dpyinfo
->font_table
[i
].name
);
11045 if (dpyinfo
->font_table
)
11047 if (dpyinfo
->font_table
->font_encoder
)
11048 xfree (dpyinfo
->font_table
->font_encoder
);
11049 xfree (dpyinfo
->font_table
);
11051 if (dpyinfo
->x_id_name
)
11052 xfree (dpyinfo
->x_id_name
);
11053 if (dpyinfo
->color_cells
)
11054 xfree (dpyinfo
->color_cells
);
11058 #ifdef USE_X_TOOLKIT
11060 /* Atimer callback function for TIMER. Called every 0.1s to process
11061 Xt timeouts, if needed. We must avoid calling XtAppPending as
11062 much as possible because that function does an implicit XFlush
11063 that slows us down. */
11066 x_process_timeouts (timer
)
11067 struct atimer
*timer
;
11070 x_timeout_atimer_activated_flag
= 0;
11071 if (toolkit_scroll_bar_interaction
|| popup_activated ())
11073 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
11074 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
11075 /* Reactivate the atimer for next time. */
11076 x_activate_timeout_atimer ();
11081 /* Install an asynchronous timer that processes Xt timeout events
11082 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
11083 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
11084 function whenever these variables are set. This is necessary
11085 because some widget sets use timeouts internally, for example the
11086 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
11087 processed, these widgets don't behave normally. */
11090 x_activate_timeout_atimer ()
11093 if (!x_timeout_atimer_activated_flag
)
11095 EMACS_TIME interval
;
11097 EMACS_SET_SECS_USECS (interval
, 0, 100000);
11098 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
11099 x_timeout_atimer_activated_flag
= 1;
11104 #endif /* USE_X_TOOLKIT */
11107 /* Set up use of X before we make the first connection. */
11109 extern frame_parm_handler x_frame_parm_handlers
[];
11111 static struct redisplay_interface x_redisplay_interface
=
11113 x_frame_parm_handlers
,
11117 x_clear_end_of_line
,
11119 x_after_update_window_line
,
11120 x_update_window_begin
,
11121 x_update_window_end
,
11127 0, /* flush_display_optional */
11129 x_clear_window_mouse_face
,
11130 x_get_glyph_overhangs
,
11131 x_fix_overlapping_area
,
11132 x_draw_fringe_bitmap
,
11133 0, /* define_fringe_bitmap */
11134 0, /* destroy_fringe_bitmap */
11137 x_compute_glyph_string_overhangs
,
11138 x_draw_glyph_string
,
11139 x_define_frame_cursor
,
11140 x_clear_frame_area
,
11141 x_draw_window_cursor
,
11142 x_draw_vertical_window_border
,
11143 x_shift_glyphs_for_insert
11149 rif
= &x_redisplay_interface
;
11151 clear_frame_hook
= x_clear_frame
;
11152 ins_del_lines_hook
= x_ins_del_lines
;
11153 delete_glyphs_hook
= x_delete_glyphs
;
11154 ring_bell_hook
= XTring_bell
;
11155 reset_terminal_modes_hook
= XTreset_terminal_modes
;
11156 set_terminal_modes_hook
= XTset_terminal_modes
;
11157 update_begin_hook
= x_update_begin
;
11158 update_end_hook
= x_update_end
;
11159 set_terminal_window_hook
= XTset_terminal_window
;
11160 read_socket_hook
= XTread_socket
;
11161 frame_up_to_date_hook
= XTframe_up_to_date
;
11162 mouse_position_hook
= XTmouse_position
;
11163 frame_rehighlight_hook
= XTframe_rehighlight
;
11164 frame_raise_lower_hook
= XTframe_raise_lower
;
11165 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
11166 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
11167 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
11168 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
11169 fullscreen_hook
= XTfullscreen_hook
;
11171 scroll_region_ok
= 1; /* we'll scroll partial frames */
11172 char_ins_del_ok
= 1;
11173 line_ins_del_ok
= 1; /* we'll just blt 'em */
11174 fast_clear_end_of_line
= 1; /* X does this well */
11175 memory_below_frame
= 0; /* we don't remember what scrolls
11180 last_tool_bar_item
= -1;
11181 any_help_event_p
= 0;
11182 ignore_next_mouse_click_timeout
= 0;
11184 x_session_initialized
= 0;
11188 current_count
= -1;
11191 /* Try to use interrupt input; if we can't, then start polling. */
11192 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
11194 #ifdef USE_X_TOOLKIT
11195 XtToolkitInitialize ();
11197 Xt_app_con
= XtCreateApplicationContext ();
11199 /* Register a converter from strings to pixels, which uses
11200 Emacs' color allocation infrastructure. */
11201 XtAppSetTypeConverter (Xt_app_con
,
11202 XtRString
, XtRPixel
, cvt_string_to_pixel
,
11203 cvt_string_to_pixel_args
,
11204 XtNumber (cvt_string_to_pixel_args
),
11205 XtCacheByDisplay
, cvt_pixel_dtor
);
11207 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
11210 #ifdef USE_TOOLKIT_SCROLL_BARS
11212 xaw3d_arrow_scroll
= False
;
11213 xaw3d_pick_top
= True
;
11217 /* Note that there is no real way portable across R3/R4 to get the
11218 original error handler. */
11219 XSetErrorHandler (x_error_handler
);
11220 XSetIOErrorHandler (x_io_error_quitter
);
11222 /* Disable Window Change signals; they are handled by X events. */
11224 signal (SIGWINCH
, SIG_DFL
);
11225 #endif /* SIGWINCH */
11227 signal (SIGPIPE
, x_connection_signal
);
11234 x_error_message
= NULL
;
11236 staticpro (&x_display_name_list
);
11237 x_display_name_list
= Qnil
;
11239 staticpro (&last_mouse_scroll_bar
);
11240 last_mouse_scroll_bar
= Qnil
;
11242 staticpro (&Qvendor_specific_keysyms
);
11243 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
11245 staticpro (&Qutf_8
);
11246 Qutf_8
= intern ("utf-8");
11247 staticpro (&Qlatin_1
);
11248 Qlatin_1
= intern ("latin-1");
11250 staticpro (&last_mouse_press_frame
);
11251 last_mouse_press_frame
= Qnil
;
11253 DEFVAR_BOOL ("x-use-underline-position-properties",
11254 &x_use_underline_position_properties
,
11255 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
11256 A value of nil means ignore them. If you encounter fonts with bogus
11257 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
11258 to 4.1, set this to nil. */);
11259 x_use_underline_position_properties
= 1;
11261 DEFVAR_BOOL ("x-underline-at-descent-line",
11262 &x_underline_at_descent_line
,
11263 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
11264 A value of nil means to draw the underline according to the value of the
11265 variable `x-use-underline-position-properties', which is usually at the
11266 baseline level. The default value is nil. */);
11267 x_underline_at_descent_line
= 0;
11269 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
11270 &x_mouse_click_focus_ignore_position
,
11271 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
11272 This variable is only used when the window manager requires that you
11273 click on a frame to select it (give it focus). In that case, a value
11274 of nil, means that the selected window and cursor position changes to
11275 reflect the mouse click position, while a non-nil value means that the
11276 selected window or cursor position is preserved. */);
11277 x_mouse_click_focus_ignore_position
= 0;
11279 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
11280 doc
: /* What X toolkit scroll bars Emacs uses.
11281 A value of nil means Emacs doesn't use X toolkit scroll bars.
11282 Otherwise, value is a symbol describing the X toolkit. */);
11283 #ifdef USE_TOOLKIT_SCROLL_BARS
11285 Vx_toolkit_scroll_bars
= intern ("motif");
11286 #elif defined HAVE_XAW3D
11287 Vx_toolkit_scroll_bars
= intern ("xaw3d");
11289 Vx_toolkit_scroll_bars
= intern ("gtk");
11291 Vx_toolkit_scroll_bars
= intern ("xaw");
11294 Vx_toolkit_scroll_bars
= Qnil
;
11297 staticpro (&last_mouse_motion_frame
);
11298 last_mouse_motion_frame
= Qnil
;
11300 Qmodifier_value
= intern ("modifier-value");
11301 Qalt
= intern ("alt");
11302 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
11303 Qhyper
= intern ("hyper");
11304 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
11305 Qmeta
= intern ("meta");
11306 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
11307 Qsuper
= intern ("super");
11308 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
11310 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
11311 doc
: /* Which keys Emacs uses for the alt modifier.
11312 This should be one of the symbols `alt', `hyper', `meta', `super'.
11313 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
11314 is nil, which is the same as `alt'. */);
11315 Vx_alt_keysym
= Qnil
;
11317 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
11318 doc
: /* Which keys Emacs uses for the hyper modifier.
11319 This should be one of the symbols `alt', `hyper', `meta', `super'.
11320 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
11321 default is nil, which is the same as `hyper'. */);
11322 Vx_hyper_keysym
= Qnil
;
11324 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
11325 doc
: /* Which keys Emacs uses for the meta modifier.
11326 This should be one of the symbols `alt', `hyper', `meta', `super'.
11327 For example, `meta' means use the Meta_L and Meta_R keysyms. The
11328 default is nil, which is the same as `meta'. */);
11329 Vx_meta_keysym
= Qnil
;
11331 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
11332 doc
: /* Which keys Emacs uses for the super modifier.
11333 This should be one of the symbols `alt', `hyper', `meta', `super'.
11334 For example, `super' means use the Super_L and Super_R keysyms. The
11335 default is nil, which is the same as `super'. */);
11336 Vx_super_keysym
= Qnil
;
11338 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
11339 doc
: /* Hash table of character codes indexed by X keysym codes. */);
11340 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
11341 make_float (DEFAULT_REHASH_SIZE
),
11342 make_float (DEFAULT_REHASH_THRESHOLD
),
11346 #endif /* HAVE_X_WINDOWS */
11348 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
11349 (do not change this comment) */