1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 93, 94, 95, 96, 97, 98, 1999, 2000,01,02,03,04
3 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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, 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 #define ARROW_SCROLLBAR
134 #define XAW_ARROW_SCROLLBARS
135 #include <X11/Xaw3d/ScrollbarP.h>
136 #else /* !HAVE_XAW3D */
137 #include <X11/Xaw/Simple.h>
138 #include <X11/Xaw/Scrollbar.h>
139 #endif /* !HAVE_XAW3D */
141 #define XtNpickTop "pickTop"
142 #endif /* !XtNpickTop */
143 #endif /* !USE_MOTIF */
144 #endif /* USE_TOOLKIT_SCROLL_BARS */
146 #endif /* USE_X_TOOLKIT */
148 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
149 #define x_any_window_to_frame x_window_to_frame
150 #define x_top_window_to_frame x_window_to_frame
155 #ifndef XtNinitialState
156 #define XtNinitialState "initialState"
160 #define abs(x) ((x) < 0 ? -(x) : (x))
162 /* Default to using XIM if available. */
166 int use_xim
= 0; /* configure --without-xim */
171 /* Non-nil means Emacs uses toolkit scroll bars. */
173 Lisp_Object Vx_toolkit_scroll_bars
;
175 /* Non-zero means that a HELP_EVENT has been generated since Emacs
178 static int any_help_event_p
;
180 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
181 static Lisp_Object last_window
;
183 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
185 int x_use_underline_position_properties
;
187 /* This is a chain of structures for all the X displays currently in
190 struct x_display_info
*x_display_list
;
192 /* This is a list of cons cells, each of the form (NAME
193 . FONT-LIST-CACHE), one for each element of x_display_list and in
194 the same order. NAME is the name of the frame. FONT-LIST-CACHE
195 records previous values returned by x-list-fonts. */
197 Lisp_Object x_display_name_list
;
199 /* Frame being updated by update_frame. This is declared in term.c.
200 This is set by update_begin and looked at by all the XT functions.
201 It is zero while not inside an update. In that case, the XT
202 functions assume that `selected_frame' is the frame to apply to. */
204 extern struct frame
*updating_frame
;
206 /* This is a frame waiting to be auto-raised, within XTread_socket. */
208 struct frame
*pending_autoraise_frame
;
211 /* The application context for Xt use. */
212 XtAppContext Xt_app_con
;
213 static String Xt_default_resources
[] = {0};
214 #endif /* USE_X_TOOLKIT */
216 /* Non-zero means user is interacting with a toolkit scroll bar. */
218 static int toolkit_scroll_bar_interaction
;
220 /* Non-zero means to not move point as a result of clicking on a
221 frame to focus it (when focus-follows-mouse is nil). */
223 int x_mouse_click_focus_ignore_position
;
225 /* Non-zero timeout value means ignore next mouse click if it arrives
226 before that timeout elapses (i.e. as part of the same sequence of
227 events resulting from clicking on a frame to select it). */
229 static unsigned long ignore_next_mouse_click_timeout
;
233 Formerly, we used PointerMotionHintMask (in standard_event_mask)
234 so that we would have to call XQueryPointer after each MotionNotify
235 event to ask for another such event. However, this made mouse tracking
236 slow, and there was a bug that made it eventually stop.
238 Simply asking for MotionNotify all the time seems to work better.
240 In order to avoid asking for motion events and then throwing most
241 of them away or busy-polling the server for mouse positions, we ask
242 the server for pointer motion hints. This means that we get only
243 one event per group of mouse movements. "Groups" are delimited by
244 other kinds of events (focus changes and button clicks, for
245 example), or by XQueryPointer calls; when one of these happens, we
246 get another MotionNotify event the next time the mouse moves. This
247 is at least as efficient as getting motion events when mouse
248 tracking is on, and I suspect only negligibly worse when tracking
251 /* Where the mouse was last time we reported a mouse event. */
253 static XRectangle last_mouse_glyph
;
254 static Lisp_Object last_mouse_press_frame
;
256 /* The scroll bar in which the last X motion event occurred.
258 If the last X motion event occurred in a scroll bar, we set this so
259 XTmouse_position can know whether to report a scroll bar motion or
262 If the last X motion event didn't occur in a scroll bar, we set
263 this to Qnil, to tell XTmouse_position to return an ordinary motion
266 static Lisp_Object last_mouse_scroll_bar
;
268 /* This is a hack. We would really prefer that XTmouse_position would
269 return the time associated with the position it returns, but there
270 doesn't seem to be any way to wrest the time-stamp from the server
271 along with the position query. So, we just keep track of the time
272 of the last movement we received, and return that in hopes that
273 it's somewhat accurate. */
275 static Time last_mouse_movement_time
;
277 /* Incremented by XTread_socket whenever it really tries to read
281 static int volatile input_signal_count
;
283 static int input_signal_count
;
286 /* Used locally within XTread_socket. */
288 static int x_noop_count
;
290 /* Initial values of argv and argc. */
292 extern char **initial_argv
;
293 extern int initial_argc
;
295 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
297 /* Tells if a window manager is present or not. */
299 extern Lisp_Object Vx_no_window_manager
;
301 extern Lisp_Object Qeql
;
305 /* A mask of extra modifier bits to put into every keyboard char. */
307 extern EMACS_INT extra_keyboard_modifiers
;
309 /* The keysyms to use for the various modifiers. */
311 Lisp_Object Vx_alt_keysym
, Vx_hyper_keysym
, Vx_meta_keysym
, Vx_super_keysym
;
312 Lisp_Object Vx_keysym_table
;
313 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
315 static Lisp_Object Qvendor_specific_keysyms
;
316 static Lisp_Object Qlatin_1
;
318 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
319 extern int x_bitmap_mask
P_ ((FRAME_PTR
, int));
321 static int x_alloc_nearest_color_1
P_ ((Display
*, Colormap
, XColor
*));
322 static void x_set_window_size_1
P_ ((struct frame
*, int, int, int));
323 static const XColor
*x_color_cells
P_ ((Display
*, int *));
324 static void x_update_window_end
P_ ((struct window
*, int, int));
325 void x_delete_display
P_ ((struct x_display_info
*));
326 static unsigned int x_x_to_emacs_modifiers
P_ ((struct x_display_info
*,
328 static int x_io_error_quitter
P_ ((Display
*));
329 int x_catch_errors
P_ ((Display
*));
330 void x_uncatch_errors
P_ ((Display
*, int));
331 void x_lower_frame
P_ ((struct frame
*));
332 void x_scroll_bar_clear
P_ ((struct frame
*));
333 int x_had_errors_p
P_ ((Display
*));
334 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
335 void x_raise_frame
P_ ((struct frame
*));
336 void x_set_window_size
P_ ((struct frame
*, int, int, int));
337 void x_wm_set_window_state
P_ ((struct frame
*, int));
338 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
339 void x_initialize
P_ ((void));
340 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
341 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
342 static void x_update_end
P_ ((struct frame
*));
343 static void XTframe_up_to_date
P_ ((struct frame
*));
344 static void XTset_terminal_modes
P_ ((void));
345 static void XTreset_terminal_modes
P_ ((void));
346 static void x_clear_frame
P_ ((void));
347 static void frame_highlight
P_ ((struct frame
*));
348 static void frame_unhighlight
P_ ((struct frame
*));
349 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
350 static void x_focus_changed
P_ ((int, int, struct x_display_info
*,
351 struct frame
*, struct input_event
*));
352 static void x_detect_focus_change
P_ ((struct x_display_info
*,
353 XEvent
*, struct input_event
*));
354 static void XTframe_rehighlight
P_ ((struct frame
*));
355 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
356 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
357 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
358 enum text_cursor_kinds
));
360 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*, GC
));
361 static void x_flush
P_ ((struct frame
*f
));
362 static void x_update_begin
P_ ((struct frame
*));
363 static void x_update_window_begin
P_ ((struct window
*));
364 static void x_after_update_window_line
P_ ((struct glyph_row
*));
365 static struct scroll_bar
*x_window_to_scroll_bar
P_ ((Display
*, Window
));
366 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
367 enum scroll_bar_part
*,
368 Lisp_Object
*, Lisp_Object
*,
370 static void x_check_fullscreen
P_ ((struct frame
*));
371 static void x_check_expected_move
P_ ((struct frame
*));
372 static int handle_one_xevent
P_ ((struct x_display_info
*, XEvent
*,
373 int *, struct input_event
*));
376 /* Flush display of frame F, or of all frames if F is null. */
385 Lisp_Object rest
, frame
;
386 FOR_EACH_FRAME (rest
, frame
)
387 x_flush (XFRAME (frame
));
389 else if (FRAME_X_P (f
))
390 XFlush (FRAME_X_DISPLAY (f
));
395 /* Remove calls to XFlush by defining XFlush to an empty replacement.
396 Calls to XFlush should be unnecessary because the X output buffer
397 is flushed automatically as needed by calls to XPending,
398 XNextEvent, or XWindowEvent according to the XFlush man page.
399 XTread_socket calls XPending. Removing XFlush improves
402 #define XFlush(DISPLAY) (void) 0
405 /***********************************************************************
407 ***********************************************************************/
411 /* This is a function useful for recording debugging information about
412 the sequence of occurrences in this file. */
420 struct record event_record
[100];
422 int event_record_index
;
424 record_event (locus
, type
)
428 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
429 event_record_index
= 0;
431 event_record
[event_record_index
].locus
= locus
;
432 event_record
[event_record_index
].type
= type
;
433 event_record_index
++;
440 /* Return the struct x_display_info corresponding to DPY. */
442 struct x_display_info
*
443 x_display_info_for_display (dpy
)
446 struct x_display_info
*dpyinfo
;
448 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
449 if (dpyinfo
->display
== dpy
)
457 /***********************************************************************
458 Starting and ending an update
459 ***********************************************************************/
461 /* Start an update of frame F. This function is installed as a hook
462 for update_begin, i.e. it is called when update_begin is called.
463 This function is called prior to calls to x_update_window_begin for
464 each window being updated. Currently, there is nothing to do here
465 because all interesting stuff is done on a window basis. */
475 /* Start update of window W. Set the global variable updated_window
476 to the window being updated and set output_cursor to the cursor
480 x_update_window_begin (w
)
483 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
484 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
487 set_output_cursor (&w
->cursor
);
491 if (f
== display_info
->mouse_face_mouse_frame
)
493 /* Don't do highlighting for mouse motion during the update. */
494 display_info
->mouse_face_defer
= 1;
496 /* If F needs to be redrawn, simply forget about any prior mouse
498 if (FRAME_GARBAGED_P (f
))
499 display_info
->mouse_face_window
= Qnil
;
501 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
502 their mouse_face_p flag set, which means that they are always
503 unequal to rows in a desired matrix which never have that
504 flag set. So, rows containing mouse-face glyphs are never
505 scrolled, and we don't have to switch the mouse highlight off
506 here to prevent it from being scrolled. */
508 /* Can we tell that this update does not affect the window
509 where the mouse highlight is? If so, no need to turn off.
510 Likewise, don't do anything if the frame is garbaged;
511 in that case, the frame's current matrix that we would use
512 is all wrong, and we will redisplay that line anyway. */
513 if (!NILP (display_info
->mouse_face_window
)
514 && w
== XWINDOW (display_info
->mouse_face_window
))
518 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
519 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
522 if (i
< w
->desired_matrix
->nrows
)
523 clear_mouse_face (display_info
);
532 /* Draw a vertical window border from (x,y0) to (x,y1) */
535 x_draw_vertical_window_border (w
, x
, y0
, y1
)
539 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
541 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
542 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
545 /* End update of window W (which is equal to updated_window).
547 Draw vertical borders between horizontally adjacent windows, and
548 display W's cursor if CURSOR_ON_P is non-zero.
550 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
551 glyphs in mouse-face were overwritten. In that case we have to
552 make sure that the mouse-highlight is properly redrawn.
554 W may be a menu bar pseudo-window in case we don't have X toolkit
555 support. Such windows don't have a cursor, so don't display it
559 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
561 int cursor_on_p
, mouse_face_overwritten_p
;
563 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
565 if (!w
->pseudo_window_p
)
570 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
572 output_cursor
.x
, output_cursor
.y
);
574 if (draw_window_fringes (w
, 1))
575 x_draw_vertical_border (w
);
580 /* If a row with mouse-face was overwritten, arrange for
581 XTframe_up_to_date to redisplay the mouse highlight. */
582 if (mouse_face_overwritten_p
)
584 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
585 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
586 dpyinfo
->mouse_face_window
= Qnil
;
589 updated_window
= NULL
;
593 /* End update of frame F. This function is installed as a hook in
600 /* Mouse highlight may be displayed again. */
601 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
605 XFlush (FRAME_X_DISPLAY (f
));
611 /* This function is called from various places in xdisp.c whenever a
612 complete update has been performed. The global variable
613 updated_window is not available here. */
616 XTframe_up_to_date (f
)
621 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
623 if (dpyinfo
->mouse_face_deferred_gc
624 || f
== dpyinfo
->mouse_face_mouse_frame
)
627 if (dpyinfo
->mouse_face_mouse_frame
)
628 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
629 dpyinfo
->mouse_face_mouse_x
,
630 dpyinfo
->mouse_face_mouse_y
);
631 dpyinfo
->mouse_face_deferred_gc
= 0;
638 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
639 arrow bitmaps, or clear the fringes if no bitmaps are required
640 before DESIRED_ROW is made current. The window being updated is
641 found in updated_window. This function It is called from
642 update_window_line only if it is known that there are differences
643 between bitmaps to be drawn between current row and DESIRED_ROW. */
646 x_after_update_window_line (desired_row
)
647 struct glyph_row
*desired_row
;
649 struct window
*w
= updated_window
;
655 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
656 desired_row
->redraw_fringe_bitmaps_p
= 1;
658 /* When a window has disappeared, make sure that no rest of
659 full-width rows stays visible in the internal border. Could
660 check here if updated_window is the leftmost/rightmost window,
661 but I guess it's not worth doing since vertically split windows
662 are almost never used, internal border is rarely set, and the
663 overhead is very small. */
664 if (windows_or_buffers_changed
665 && desired_row
->full_width_p
666 && (f
= XFRAME (w
->frame
),
667 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
669 && (height
= desired_row
->visible_height
,
672 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
674 /* Internal border is drawn below the tool bar. */
675 if (WINDOWP (f
->tool_bar_window
)
676 && w
== XWINDOW (f
->tool_bar_window
))
680 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
681 0, y
, width
, height
, False
);
682 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
683 FRAME_PIXEL_WIDTH (f
) - width
,
684 y
, width
, height
, False
);
690 x_draw_fringe_bitmap (w
, row
, p
)
692 struct glyph_row
*row
;
693 struct draw_fringe_bitmap_params
*p
;
695 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
696 Display
*display
= FRAME_X_DISPLAY (f
);
697 Window window
= FRAME_X_WINDOW (f
);
698 GC gc
= f
->output_data
.x
->normal_gc
;
699 struct face
*face
= p
->face
;
702 /* Must clip because of partially visible lines. */
703 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
706 /* Adjust position of "bottom aligned" bitmap on partially
709 int oldVH
= row
->visible_height
;
710 row
->visible_height
= p
->h
;
711 row
->y
-= rowY
- p
->y
;
712 x_clip_to_row (w
, row
, gc
);
714 row
->visible_height
= oldVH
;
717 x_clip_to_row (w
, row
, gc
);
719 if (p
->bx
>= 0 && !p
->overlay_p
)
721 /* In case the same realized face is used for fringes and
722 for something displayed in the text (e.g. face `region' on
723 mono-displays, the fill style may have been changed to
724 FillSolid in x_draw_glyph_string_background. */
726 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
728 XSetForeground (display
, face
->gc
, face
->background
);
730 XFillRectangle (display
, window
, face
->gc
,
731 p
->bx
, p
->by
, p
->nx
, p
->ny
);
734 XSetForeground (display
, face
->gc
, face
->foreground
);
740 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
741 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
745 bits
= (unsigned char *)(p
->bits
+ p
->dh
);
747 bits
= (unsigned char *)p
->bits
+ p
->dh
;
749 /* Draw the bitmap. I believe these small pixmaps can be cached
751 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
753 ? (p
->overlay_p
? face
->background
754 : f
->output_data
.x
->cursor_pixel
)
756 face
->background
, depth
);
760 clipmask
= XCreatePixmapFromBitmapData (display
,
761 FRAME_X_DISPLAY_INFO (f
)->root_window
,
764 gcv
.clip_mask
= clipmask
;
765 gcv
.clip_x_origin
= p
->x
;
766 gcv
.clip_y_origin
= p
->y
;
767 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
770 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
771 p
->wd
, p
->h
, p
->x
, p
->y
);
772 XFreePixmap (display
, pixmap
);
776 gcv
.clip_mask
= (Pixmap
) 0;
777 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
778 XFreePixmap (display
, clipmask
);
782 XSetClipMask (display
, gc
, None
);
787 /* This is called when starting Emacs and when restarting after
788 suspend. When starting Emacs, no X window is mapped. And nothing
789 must be done to Emacs's own window if it is suspended (though that
793 XTset_terminal_modes ()
797 /* This is called when exiting or suspending Emacs. Exiting will make
798 the X-windows go away, and suspending requires no action. */
801 XTreset_terminal_modes ()
807 /***********************************************************************
809 ***********************************************************************/
811 /* Function prototypes of this page. */
813 static int x_encode_char
P_ ((int, XChar2b
*, struct font_info
*, int *));
816 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
817 is not contained in the font. */
820 x_per_char_metric (font
, char2b
, font_type
)
823 int font_type
; /* unused on X */
825 /* The result metric information. */
826 XCharStruct
*pcm
= NULL
;
828 xassert (font
&& char2b
);
830 if (font
->per_char
!= NULL
)
832 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
834 /* min_char_or_byte2 specifies the linear character index
835 corresponding to the first element of the per_char array,
836 max_char_or_byte2 is the index of the last character. A
837 character with non-zero CHAR2B->byte1 is not in the font.
838 A character with byte2 less than min_char_or_byte2 or
839 greater max_char_or_byte2 is not in the font. */
840 if (char2b
->byte1
== 0
841 && char2b
->byte2
>= font
->min_char_or_byte2
842 && char2b
->byte2
<= font
->max_char_or_byte2
)
843 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
847 /* If either min_byte1 or max_byte1 are nonzero, both
848 min_char_or_byte2 and max_char_or_byte2 are less than
849 256, and the 2-byte character index values corresponding
850 to the per_char array element N (counting from 0) are:
852 byte1 = N/D + min_byte1
853 byte2 = N\D + min_char_or_byte2
857 D = max_char_or_byte2 - min_char_or_byte2 + 1
859 \ = integer modulus */
860 if (char2b
->byte1
>= font
->min_byte1
861 && char2b
->byte1
<= font
->max_byte1
862 && char2b
->byte2
>= font
->min_char_or_byte2
863 && char2b
->byte2
<= font
->max_char_or_byte2
)
865 pcm
= (font
->per_char
866 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
867 * (char2b
->byte1
- font
->min_byte1
))
868 + (char2b
->byte2
- font
->min_char_or_byte2
));
874 /* If the per_char pointer is null, all glyphs between the first
875 and last character indexes inclusive have the same
876 information, as given by both min_bounds and max_bounds. */
877 if (char2b
->byte2
>= font
->min_char_or_byte2
878 && char2b
->byte2
<= font
->max_char_or_byte2
)
879 pcm
= &font
->max_bounds
;
883 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
888 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
889 the two-byte form of C. Encoding is returned in *CHAR2B. */
892 x_encode_char (c
, char2b
, font_info
, two_byte_p
)
895 struct font_info
*font_info
;
898 int charset
= CHAR_CHARSET (c
);
899 XFontStruct
*font
= font_info
->font
;
901 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
902 This may be either a program in a special encoder language or a
904 if (font_info
->font_encoder
)
906 /* It's a program. */
907 struct ccl_program
*ccl
= font_info
->font_encoder
;
909 if (CHARSET_DIMENSION (charset
) == 1)
911 ccl
->reg
[0] = charset
;
912 ccl
->reg
[1] = char2b
->byte2
;
917 ccl
->reg
[0] = charset
;
918 ccl
->reg
[1] = char2b
->byte1
;
919 ccl
->reg
[2] = char2b
->byte2
;
922 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
924 /* We assume that MSBs are appropriately set/reset by CCL
926 if (font
->max_byte1
== 0) /* 1-byte font */
927 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
929 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
931 else if (font_info
->encoding
[charset
])
933 /* Fixed encoding scheme. See fontset.h for the meaning of the
935 int enc
= font_info
->encoding
[charset
];
937 if ((enc
== 1 || enc
== 2)
938 && CHARSET_DIMENSION (charset
) == 2)
939 char2b
->byte1
|= 0x80;
941 if (enc
== 1 || enc
== 3)
942 char2b
->byte2
|= 0x80;
946 *two_byte_p
= ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
948 return FONT_TYPE_UNKNOWN
;
953 /***********************************************************************
955 ***********************************************************************/
959 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
960 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
961 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
963 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
964 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
965 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
966 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
967 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
968 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
969 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
970 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
971 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
972 unsigned long *, double, int));
973 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
974 double, int, unsigned long));
975 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
976 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
977 static void x_draw_image_relief
P_ ((struct glyph_string
*));
978 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
979 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
980 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
982 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
983 int, int, int, int, int, int,
985 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
986 int, int, int, XRectangle
*));
989 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
993 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
998 struct glyph_string
*s
;
1000 if (s
->font
== FRAME_FONT (s
->f
)
1001 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1002 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1004 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
1007 /* Cursor on non-default face: must merge. */
1011 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
1012 xgcv
.foreground
= s
->face
->background
;
1014 /* If the glyph would be invisible, try a different foreground. */
1015 if (xgcv
.foreground
== xgcv
.background
)
1016 xgcv
.foreground
= s
->face
->foreground
;
1017 if (xgcv
.foreground
== xgcv
.background
)
1018 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
1019 if (xgcv
.foreground
== xgcv
.background
)
1020 xgcv
.foreground
= s
->face
->foreground
;
1022 /* Make sure the cursor is distinct from text in this face. */
1023 if (xgcv
.background
== s
->face
->background
1024 && xgcv
.foreground
== s
->face
->foreground
)
1026 xgcv
.background
= s
->face
->foreground
;
1027 xgcv
.foreground
= s
->face
->background
;
1030 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1031 xgcv
.font
= s
->font
->fid
;
1032 xgcv
.graphics_exposures
= False
;
1033 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
1035 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1036 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1039 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1040 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1042 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1047 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1050 x_set_mouse_face_gc (s
)
1051 struct glyph_string
*s
;
1056 /* What face has to be used last for the mouse face? */
1057 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1058 face
= FACE_FROM_ID (s
->f
, face_id
);
1060 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1062 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1063 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
1065 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
1066 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1067 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1069 /* If font in this face is same as S->font, use it. */
1070 if (s
->font
== s
->face
->font
)
1071 s
->gc
= s
->face
->gc
;
1074 /* Otherwise construct scratch_cursor_gc with values from FACE
1079 xgcv
.background
= s
->face
->background
;
1080 xgcv
.foreground
= s
->face
->foreground
;
1081 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1082 xgcv
.font
= s
->font
->fid
;
1083 xgcv
.graphics_exposures
= False
;
1084 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
1086 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1087 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1090 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1091 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1093 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1096 xassert (s
->gc
!= 0);
1100 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1101 Faces to use in the mode line have already been computed when the
1102 matrix was built, so there isn't much to do, here. */
1105 x_set_mode_line_face_gc (s
)
1106 struct glyph_string
*s
;
1108 s
->gc
= s
->face
->gc
;
1112 /* Set S->gc of glyph string S for drawing that glyph string. Set
1113 S->stippled_p to a non-zero value if the face of S has a stipple
1117 x_set_glyph_string_gc (s
)
1118 struct glyph_string
*s
;
1120 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1122 if (s
->hl
== DRAW_NORMAL_TEXT
)
1124 s
->gc
= s
->face
->gc
;
1125 s
->stippled_p
= s
->face
->stipple
!= 0;
1127 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1129 x_set_mode_line_face_gc (s
);
1130 s
->stippled_p
= s
->face
->stipple
!= 0;
1132 else if (s
->hl
== DRAW_CURSOR
)
1134 x_set_cursor_gc (s
);
1137 else if (s
->hl
== DRAW_MOUSE_FACE
)
1139 x_set_mouse_face_gc (s
);
1140 s
->stippled_p
= s
->face
->stipple
!= 0;
1142 else if (s
->hl
== DRAW_IMAGE_RAISED
1143 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1145 s
->gc
= s
->face
->gc
;
1146 s
->stippled_p
= s
->face
->stipple
!= 0;
1150 s
->gc
= s
->face
->gc
;
1151 s
->stippled_p
= s
->face
->stipple
!= 0;
1154 /* GC must have been set. */
1155 xassert (s
->gc
!= 0);
1159 /* Set clipping for output of glyph string S. S may be part of a mode
1160 line or menu if we don't have X toolkit support. */
1163 x_set_glyph_string_clipping (s
)
1164 struct glyph_string
*s
;
1167 get_glyph_string_clip_rect (s
, &r
);
1168 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
1173 Compute left and right overhang of glyph string S. If S is a glyph
1174 string for a composition, assume overhangs don't exist. */
1177 x_compute_glyph_string_overhangs (s
)
1178 struct glyph_string
*s
;
1181 && s
->first_glyph
->type
== CHAR_GLYPH
)
1184 int direction
, font_ascent
, font_descent
;
1185 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
1186 &font_ascent
, &font_descent
, &cs
);
1187 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
1188 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
1193 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1196 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1197 struct glyph_string
*s
;
1201 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1202 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1203 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1204 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1208 /* Draw the background of glyph_string S. If S->background_filled_p
1209 is non-zero don't draw it. FORCE_P non-zero means draw the
1210 background even if it wouldn't be drawn normally. This is used
1211 when a string preceding S draws into the background of S, or S
1212 contains the first component of a composition. */
1215 x_draw_glyph_string_background (s
, force_p
)
1216 struct glyph_string
*s
;
1219 /* Nothing to do if background has already been drawn or if it
1220 shouldn't be drawn in the first place. */
1221 if (!s
->background_filled_p
)
1223 int box_line_width
= max (s
->face
->box_line_width
, 0);
1227 /* Fill background with a stipple pattern. */
1228 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1229 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1230 s
->y
+ box_line_width
,
1231 s
->background_width
,
1232 s
->height
- 2 * box_line_width
);
1233 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1234 s
->background_filled_p
= 1;
1236 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1237 || s
->font_not_found_p
1238 || s
->extends_to_end_of_line_p
1241 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1242 s
->background_width
,
1243 s
->height
- 2 * box_line_width
);
1244 s
->background_filled_p
= 1;
1250 /* Draw the foreground of glyph string S. */
1253 x_draw_glyph_string_foreground (s
)
1254 struct glyph_string
*s
;
1258 /* If first glyph of S has a left box line, start drawing the text
1259 of S to the right of that box line. */
1260 if (s
->face
->box
!= FACE_NO_BOX
1261 && s
->first_glyph
->left_box_line_p
)
1262 x
= s
->x
+ abs (s
->face
->box_line_width
);
1266 /* Draw characters of S as rectangles if S's font could not be
1268 if (s
->font_not_found_p
)
1270 for (i
= 0; i
< s
->nchars
; ++i
)
1272 struct glyph
*g
= s
->first_glyph
+ i
;
1273 XDrawRectangle (s
->display
, s
->window
,
1274 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1276 x
+= g
->pixel_width
;
1281 char *char1b
= (char *) s
->char2b
;
1282 int boff
= s
->font_info
->baseline_offset
;
1284 if (s
->font_info
->vertical_centering
)
1285 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
1287 /* If we can use 8-bit functions, condense S->char2b. */
1289 for (i
= 0; i
< s
->nchars
; ++i
)
1290 char1b
[i
] = s
->char2b
[i
].byte2
;
1292 /* Draw text with XDrawString if background has already been
1293 filled. Otherwise, use XDrawImageString. (Note that
1294 XDrawImageString is usually faster than XDrawString.) Always
1295 use XDrawImageString when drawing the cursor so that there is
1296 no chance that characters under a box cursor are invisible. */
1297 if (s
->for_overlaps_p
1298 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1300 /* Draw characters with 16-bit or 8-bit functions. */
1302 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
1303 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1305 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
1306 s
->ybase
- boff
, char1b
, s
->nchars
);
1311 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
1312 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1314 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
1315 s
->ybase
- boff
, char1b
, s
->nchars
);
1318 if (s
->face
->overstrike
)
1320 /* For overstriking (to simulate bold-face), draw the
1321 characters again shifted to the right by one pixel. */
1323 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
+ 1,
1324 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1326 XDrawString (s
->display
, s
->window
, s
->gc
, x
+ 1,
1327 s
->ybase
- boff
, char1b
, s
->nchars
);
1332 /* Draw the foreground of composite glyph string S. */
1335 x_draw_composite_glyph_string_foreground (s
)
1336 struct glyph_string
*s
;
1340 /* If first glyph of S has a left box line, start drawing the text
1341 of S to the right of that box line. */
1342 if (s
->face
->box
!= FACE_NO_BOX
1343 && s
->first_glyph
->left_box_line_p
)
1344 x
= s
->x
+ abs (s
->face
->box_line_width
);
1348 /* S is a glyph string for a composition. S->gidx is the index of
1349 the first character drawn for glyphs of this composition.
1350 S->gidx == 0 means we are drawing the very first character of
1351 this composition. */
1353 /* Draw a rectangle for the composition if the font for the very
1354 first character of the composition could not be loaded. */
1355 if (s
->font_not_found_p
)
1358 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1359 s
->width
- 1, s
->height
- 1);
1363 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
1365 XDrawString16 (s
->display
, s
->window
, s
->gc
,
1366 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
1367 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1369 if (s
->face
->overstrike
)
1370 XDrawString16 (s
->display
, s
->window
, s
->gc
,
1371 x
+ s
->cmp
->offsets
[s
->gidx
* 2] + 1,
1372 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1379 #ifdef USE_X_TOOLKIT
1381 static struct frame
*x_frame_of_widget
P_ ((Widget
));
1382 static Boolean cvt_string_to_pixel
P_ ((Display
*, XrmValue
*, Cardinal
*,
1383 XrmValue
*, XrmValue
*, XtPointer
*));
1384 static void cvt_pixel_dtor
P_ ((XtAppContext
, XrmValue
*, XtPointer
,
1385 XrmValue
*, Cardinal
*));
1388 /* Return the frame on which widget WIDGET is used.. Abort if frame
1389 cannot be determined. */
1391 static struct frame
*
1392 x_frame_of_widget (widget
)
1395 struct x_display_info
*dpyinfo
;
1399 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1401 /* Find the top-level shell of the widget. Note that this function
1402 can be called when the widget is not yet realized, so XtWindow
1403 (widget) == 0. That's the reason we can't simply use
1404 x_any_window_to_frame. */
1405 while (!XtIsTopLevelShell (widget
))
1406 widget
= XtParent (widget
);
1408 /* Look for a frame with that top-level widget. Allocate the color
1409 on that frame to get the right gamma correction value. */
1410 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1411 if (GC_FRAMEP (XCAR (tail
))
1412 && (f
= XFRAME (XCAR (tail
)),
1413 (f
->output_data
.nothing
!= 1
1414 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1415 && f
->output_data
.x
->widget
== widget
)
1422 /* Allocate the color COLOR->pixel on the screen and display of
1423 widget WIDGET in colormap CMAP. If an exact match cannot be
1424 allocated, try the nearest color available. Value is non-zero
1425 if successful. This is called from lwlib. */
1428 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
1433 struct frame
*f
= x_frame_of_widget (widget
);
1434 return x_alloc_nearest_color (f
, cmap
, color
);
1438 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1439 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1440 If this produces the same color as PIXEL, try a color where all RGB
1441 values have DELTA added. Return the allocated color in *PIXEL.
1442 DISPLAY is the X display, CMAP is the colormap to operate on.
1443 Value is non-zero if successful. */
1446 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
1450 unsigned long *pixel
;
1454 struct frame
*f
= x_frame_of_widget (widget
);
1455 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1459 /* Structure specifying which arguments should be passed by Xt to
1460 cvt_string_to_pixel. We want the widget's screen and colormap. */
1462 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1464 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1466 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1471 /* The address of this variable is returned by
1472 cvt_string_to_pixel. */
1474 static Pixel cvt_string_to_pixel_value
;
1477 /* Convert a color name to a pixel color.
1479 DPY is the display we are working on.
1481 ARGS is an array of *NARGS XrmValue structures holding additional
1482 information about the widget for which the conversion takes place.
1483 The contents of this array are determined by the specification
1484 in cvt_string_to_pixel_args.
1486 FROM is a pointer to an XrmValue which points to the color name to
1487 convert. TO is an XrmValue in which to return the pixel color.
1489 CLOSURE_RET is a pointer to user-data, in which we record if
1490 we allocated the color or not.
1492 Value is True if successful, False otherwise. */
1495 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
1499 XrmValue
*from
, *to
;
1500 XtPointer
*closure_ret
;
1510 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1511 "wrongParameters", "cvt_string_to_pixel",
1513 "Screen and colormap args required", NULL
, NULL
);
1517 screen
= *(Screen
**) args
[0].addr
;
1518 cmap
= *(Colormap
*) args
[1].addr
;
1519 color_name
= (String
) from
->addr
;
1521 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1523 *closure_ret
= (XtPointer
) False
;
1524 pixel
= WhitePixelOfScreen (screen
);
1526 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1528 *closure_ret
= (XtPointer
) False
;
1529 pixel
= BlackPixelOfScreen (screen
);
1531 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1532 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1534 pixel
= color
.pixel
;
1535 *closure_ret
= (XtPointer
) True
;
1540 Cardinal nparams
= 1;
1542 params
[0] = color_name
;
1543 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1544 "badValue", "cvt_string_to_pixel",
1545 "XtToolkitError", "Invalid color `%s'",
1550 if (to
->addr
!= NULL
)
1552 if (to
->size
< sizeof (Pixel
))
1554 to
->size
= sizeof (Pixel
);
1558 *(Pixel
*) to
->addr
= pixel
;
1562 cvt_string_to_pixel_value
= pixel
;
1563 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1566 to
->size
= sizeof (Pixel
);
1571 /* Free a pixel color which was previously allocated via
1572 cvt_string_to_pixel. This is registered as the destructor
1573 for this type of resource via XtSetTypeConverter.
1575 APP is the application context in which we work.
1577 TO is a pointer to an XrmValue holding the color to free.
1578 CLOSURE is the value we stored in CLOSURE_RET for this color
1579 in cvt_string_to_pixel.
1581 ARGS and NARGS are like for cvt_string_to_pixel. */
1584 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
1593 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1595 "Screen and colormap arguments required",
1598 else if (closure
!= NULL
)
1600 /* We did allocate the pixel, so free it. */
1601 Screen
*screen
= *(Screen
**) args
[0].addr
;
1602 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1603 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1604 (Pixel
*) to
->addr
, 1);
1609 #endif /* USE_X_TOOLKIT */
1612 /* Value is an array of XColor structures for the contents of the
1613 color map of display DPY. Set *NCELLS to the size of the array.
1614 Note that this probably shouldn't be called for large color maps,
1615 say a 24-bit TrueColor map. */
1617 static const XColor
*
1618 x_color_cells (dpy
, ncells
)
1622 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1624 if (dpyinfo
->color_cells
== NULL
)
1626 Screen
*screen
= dpyinfo
->screen
;
1629 dpyinfo
->ncolor_cells
1630 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1631 dpyinfo
->color_cells
1632 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1633 * sizeof *dpyinfo
->color_cells
);
1635 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1636 dpyinfo
->color_cells
[i
].pixel
= i
;
1638 XQueryColors (dpy
, dpyinfo
->cmap
,
1639 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1642 *ncells
= dpyinfo
->ncolor_cells
;
1643 return dpyinfo
->color_cells
;
1647 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1648 colors in COLORS. Use cached information, if available. */
1651 x_query_colors (f
, colors
, ncolors
)
1656 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1658 if (dpyinfo
->color_cells
)
1661 for (i
= 0; i
< ncolors
; ++i
)
1663 unsigned long pixel
= colors
[i
].pixel
;
1664 xassert (pixel
< dpyinfo
->ncolor_cells
);
1665 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1666 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1670 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1674 /* On frame F, translate pixel color to RGB values for the color in
1675 COLOR. Use cached information, if available. */
1678 x_query_color (f
, color
)
1682 x_query_colors (f
, color
, 1);
1686 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1687 exact match can't be allocated, try the nearest color available.
1688 Value is non-zero if successful. Set *COLOR to the color
1692 x_alloc_nearest_color_1 (dpy
, cmap
, color
)
1699 rc
= XAllocColor (dpy
, cmap
, color
);
1702 /* If we got to this point, the colormap is full, so we're going
1703 to try to get the next closest color. The algorithm used is
1704 a least-squares matching, which is what X uses for closest
1705 color matching with StaticColor visuals. */
1707 unsigned long nearest_delta
= ~0;
1709 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1711 for (nearest
= i
= 0; i
< ncells
; ++i
)
1713 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1714 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1715 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1716 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1718 if (delta
< nearest_delta
)
1721 nearest_delta
= delta
;
1725 color
->red
= cells
[nearest
].red
;
1726 color
->green
= cells
[nearest
].green
;
1727 color
->blue
= cells
[nearest
].blue
;
1728 rc
= XAllocColor (dpy
, cmap
, color
);
1732 /* If allocation succeeded, and the allocated pixel color is not
1733 equal to a cached pixel color recorded earlier, there was a
1734 change in the colormap, so clear the color cache. */
1735 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1736 XColor
*cached_color
;
1738 if (dpyinfo
->color_cells
1739 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1740 (cached_color
->red
!= color
->red
1741 || cached_color
->blue
!= color
->blue
1742 || cached_color
->green
!= color
->green
)))
1744 xfree (dpyinfo
->color_cells
);
1745 dpyinfo
->color_cells
= NULL
;
1746 dpyinfo
->ncolor_cells
= 0;
1750 #ifdef DEBUG_X_COLORS
1752 register_color (color
->pixel
);
1753 #endif /* DEBUG_X_COLORS */
1759 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1760 exact match can't be allocated, try the nearest color available.
1761 Value is non-zero if successful. Set *COLOR to the color
1765 x_alloc_nearest_color (f
, cmap
, color
)
1770 gamma_correct (f
, color
);
1771 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1775 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1776 It's necessary to do this instead of just using PIXEL directly to
1777 get color reference counts right. */
1780 x_copy_color (f
, pixel
)
1782 unsigned long pixel
;
1786 color
.pixel
= pixel
;
1788 x_query_color (f
, &color
);
1789 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1791 #ifdef DEBUG_X_COLORS
1792 register_color (pixel
);
1798 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1799 It's necessary to do this instead of just using PIXEL directly to
1800 get color reference counts right. */
1803 x_copy_dpy_color (dpy
, cmap
, pixel
)
1806 unsigned long pixel
;
1810 color
.pixel
= pixel
;
1812 XQueryColor (dpy
, cmap
, &color
);
1813 XAllocColor (dpy
, cmap
, &color
);
1815 #ifdef DEBUG_X_COLORS
1816 register_color (pixel
);
1822 /* Brightness beyond which a color won't have its highlight brightness
1825 Nominally, highlight colors for `3d' faces are calculated by
1826 brightening an object's color by a constant scale factor, but this
1827 doesn't yield good results for dark colors, so for colors who's
1828 brightness is less than this value (on a scale of 0-65535) have an
1829 use an additional additive factor.
1831 The value here is set so that the default menu-bar/mode-line color
1832 (grey75) will not have its highlights changed at all. */
1833 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1836 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1837 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1838 If this produces the same color as PIXEL, try a color where all RGB
1839 values have DELTA added. Return the allocated color in *PIXEL.
1840 DISPLAY is the X display, CMAP is the colormap to operate on.
1841 Value is non-zero if successful. */
1844 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
1848 unsigned long *pixel
;
1856 /* Get RGB color values. */
1857 color
.pixel
= *pixel
;
1858 x_query_color (f
, &color
);
1860 /* Change RGB values by specified FACTOR. Avoid overflow! */
1861 xassert (factor
>= 0);
1862 new.red
= min (0xffff, factor
* color
.red
);
1863 new.green
= min (0xffff, factor
* color
.green
);
1864 new.blue
= min (0xffff, factor
* color
.blue
);
1866 /* Calculate brightness of COLOR. */
1867 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1869 /* We only boost colors that are darker than
1870 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1871 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1872 /* Make an additive adjustment to NEW, because it's dark enough so
1873 that scaling by FACTOR alone isn't enough. */
1875 /* How far below the limit this color is (0 - 1, 1 being darker). */
1876 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1877 /* The additive adjustment. */
1878 int min_delta
= delta
* dimness
* factor
/ 2;
1882 new.red
= max (0, new.red
- min_delta
);
1883 new.green
= max (0, new.green
- min_delta
);
1884 new.blue
= max (0, new.blue
- min_delta
);
1888 new.red
= min (0xffff, min_delta
+ new.red
);
1889 new.green
= min (0xffff, min_delta
+ new.green
);
1890 new.blue
= min (0xffff, min_delta
+ new.blue
);
1894 /* Try to allocate the color. */
1895 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1898 if (new.pixel
== *pixel
)
1900 /* If we end up with the same color as before, try adding
1901 delta to the RGB values. */
1902 x_free_colors (f
, &new.pixel
, 1);
1904 new.red
= min (0xffff, delta
+ color
.red
);
1905 new.green
= min (0xffff, delta
+ color
.green
);
1906 new.blue
= min (0xffff, delta
+ color
.blue
);
1907 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1918 /* Set up the foreground color for drawing relief lines of glyph
1919 string S. RELIEF is a pointer to a struct relief containing the GC
1920 with which lines will be drawn. Use a color that is FACTOR or
1921 DELTA lighter or darker than the relief's background which is found
1922 in S->f->output_data.x->relief_background. If such a color cannot
1923 be allocated, use DEFAULT_PIXEL, instead. */
1926 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1928 struct relief
*relief
;
1931 unsigned long default_pixel
;
1934 struct x_output
*di
= f
->output_data
.x
;
1935 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1936 unsigned long pixel
;
1937 unsigned long background
= di
->relief_background
;
1938 Colormap cmap
= FRAME_X_COLORMAP (f
);
1939 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1940 Display
*dpy
= FRAME_X_DISPLAY (f
);
1942 xgcv
.graphics_exposures
= False
;
1943 xgcv
.line_width
= 1;
1945 /* Free previously allocated color. The color cell will be reused
1946 when it has been freed as many times as it was allocated, so this
1947 doesn't affect faces using the same colors. */
1949 && relief
->allocated_p
)
1951 x_free_colors (f
, &relief
->pixel
, 1);
1952 relief
->allocated_p
= 0;
1955 /* Allocate new color. */
1956 xgcv
.foreground
= default_pixel
;
1958 if (dpyinfo
->n_planes
!= 1
1959 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1961 relief
->allocated_p
= 1;
1962 xgcv
.foreground
= relief
->pixel
= pixel
;
1965 if (relief
->gc
== 0)
1967 xgcv
.stipple
= dpyinfo
->gray
;
1969 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1972 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1976 /* Set up colors for the relief lines around glyph string S. */
1979 x_setup_relief_colors (s
)
1980 struct glyph_string
*s
;
1982 struct x_output
*di
= s
->f
->output_data
.x
;
1983 unsigned long color
;
1985 if (s
->face
->use_box_color_for_shadows_p
)
1986 color
= s
->face
->box_color
;
1987 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1989 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1990 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1995 /* Get the background color of the face. */
1996 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
1997 color
= xgcv
.background
;
2000 if (di
->white_relief
.gc
== 0
2001 || color
!= di
->relief_background
)
2003 di
->relief_background
= color
;
2004 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2005 WHITE_PIX_DEFAULT (s
->f
));
2006 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2007 BLACK_PIX_DEFAULT (s
->f
));
2012 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2013 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2014 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
2015 relief. LEFT_P non-zero means draw a relief on the left side of
2016 the rectangle. RIGHT_P non-zero means draw a relief on the right
2017 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2021 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
2022 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
2024 int left_x
, top_y
, right_x
, bottom_y
, width
;
2025 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
2026 XRectangle
*clip_rect
;
2028 Display
*dpy
= FRAME_X_DISPLAY (f
);
2029 Window window
= FRAME_X_WINDOW (f
);
2034 gc
= f
->output_data
.x
->white_relief
.gc
;
2036 gc
= f
->output_data
.x
->black_relief
.gc
;
2037 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2041 for (i
= 0; i
< width
; ++i
)
2042 XDrawLine (dpy
, window
, gc
,
2043 left_x
+ i
* left_p
, top_y
+ i
,
2044 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2048 for (i
= 0; i
< width
; ++i
)
2049 XDrawLine (dpy
, window
, gc
,
2050 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
2052 XSetClipMask (dpy
, gc
, None
);
2054 gc
= f
->output_data
.x
->black_relief
.gc
;
2056 gc
= f
->output_data
.x
->white_relief
.gc
;
2057 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2061 for (i
= 0; i
< width
; ++i
)
2062 XDrawLine (dpy
, window
, gc
,
2063 left_x
+ i
* left_p
, bottom_y
- i
,
2064 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2068 for (i
= 0; i
< width
; ++i
)
2069 XDrawLine (dpy
, window
, gc
,
2070 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2072 XSetClipMask (dpy
, gc
, None
);
2076 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2077 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2078 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2079 left side of the rectangle. RIGHT_P non-zero means draw a line
2080 on the right side of the rectangle. CLIP_RECT is the clipping
2081 rectangle to use when drawing. */
2084 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2085 left_p
, right_p
, clip_rect
)
2086 struct glyph_string
*s
;
2087 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2088 XRectangle
*clip_rect
;
2092 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2093 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2094 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2097 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2098 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2102 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2103 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2106 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2107 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2111 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2112 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2114 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2115 XSetClipMask (s
->display
, s
->gc
, None
);
2119 /* Draw a box around glyph string S. */
2122 x_draw_glyph_string_box (s
)
2123 struct glyph_string
*s
;
2125 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2126 int left_p
, right_p
;
2127 struct glyph
*last_glyph
;
2128 XRectangle clip_rect
;
2130 last_x
= window_box_right (s
->w
, s
->area
);
2131 if (s
->row
->full_width_p
2132 && !s
->w
->pseudo_window_p
)
2134 last_x
+= WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH (s
->w
);
2135 if (s
->area
!= RIGHT_MARGIN_AREA
2136 || WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (s
->w
))
2137 last_x
+= WINDOW_RIGHT_FRINGE_WIDTH (s
->w
);
2140 /* The glyph that may have a right box line. */
2141 last_glyph
= (s
->cmp
|| s
->img
2143 : s
->first_glyph
+ s
->nchars
- 1);
2145 width
= abs (s
->face
->box_line_width
);
2146 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2148 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2150 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2152 bottom_y
= top_y
+ s
->height
- 1;
2154 left_p
= (s
->first_glyph
->left_box_line_p
2155 || (s
->hl
== DRAW_MOUSE_FACE
2157 || s
->prev
->hl
!= s
->hl
)));
2158 right_p
= (last_glyph
->right_box_line_p
2159 || (s
->hl
== DRAW_MOUSE_FACE
2161 || s
->next
->hl
!= s
->hl
)));
2163 get_glyph_string_clip_rect (s
, &clip_rect
);
2165 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2166 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2167 left_p
, right_p
, &clip_rect
);
2170 x_setup_relief_colors (s
);
2171 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2172 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2177 /* Draw foreground of image glyph string S. */
2180 x_draw_image_foreground (s
)
2181 struct glyph_string
*s
;
2184 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2186 /* If first glyph of S has a left box line, start drawing it to the
2187 right of that line. */
2188 if (s
->face
->box
!= FACE_NO_BOX
2189 && s
->first_glyph
->left_box_line_p
2191 x
+= abs (s
->face
->box_line_width
);
2193 /* If there is a margin around the image, adjust x- and y-position
2195 if (s
->slice
.x
== 0)
2196 x
+= s
->img
->hmargin
;
2197 if (s
->slice
.y
== 0)
2198 y
+= s
->img
->vmargin
;
2204 /* We can't set both a clip mask and use XSetClipRectangles
2205 because the latter also sets a clip mask. We also can't
2206 trust on the shape extension to be available
2207 (XShapeCombineRegion). So, compute the rectangle to draw
2209 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2212 XRectangle clip_rect
, image_rect
, r
;
2214 xgcv
.clip_mask
= s
->img
->mask
;
2215 xgcv
.clip_x_origin
= x
;
2216 xgcv
.clip_y_origin
= y
;
2217 xgcv
.function
= GXcopy
;
2218 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2220 get_glyph_string_clip_rect (s
, &clip_rect
);
2223 image_rect
.width
= s
->slice
.width
;
2224 image_rect
.height
= s
->slice
.height
;
2225 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2226 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2227 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2228 r
.width
, r
.height
, r
.x
, r
.y
);
2232 XRectangle clip_rect
, image_rect
, r
;
2234 get_glyph_string_clip_rect (s
, &clip_rect
);
2237 image_rect
.width
= s
->slice
.width
;
2238 image_rect
.height
= s
->slice
.height
;
2239 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2240 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2241 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2242 r
.width
, r
.height
, r
.x
, r
.y
);
2244 /* When the image has a mask, we can expect that at
2245 least part of a mouse highlight or a block cursor will
2246 be visible. If the image doesn't have a mask, make
2247 a block cursor visible by drawing a rectangle around
2248 the image. I believe it's looking better if we do
2249 nothing here for mouse-face. */
2250 if (s
->hl
== DRAW_CURSOR
)
2252 int r
= s
->img
->relief
;
2254 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2256 s
->slice
.width
+ r
*2 - 1,
2257 s
->slice
.height
+ r
*2 - 1);
2262 /* Draw a rectangle if image could not be loaded. */
2263 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2264 s
->slice
.width
- 1, s
->slice
.height
- 1);
2268 /* Draw a relief around the image glyph string S. */
2271 x_draw_image_relief (s
)
2272 struct glyph_string
*s
;
2274 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2277 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2279 /* If first glyph of S has a left box line, start drawing it to the
2280 right of that line. */
2281 if (s
->face
->box
!= FACE_NO_BOX
2282 && s
->first_glyph
->left_box_line_p
2284 x
+= abs (s
->face
->box_line_width
);
2286 /* If there is a margin around the image, adjust x- and y-position
2288 if (s
->slice
.x
== 0)
2289 x
+= s
->img
->hmargin
;
2290 if (s
->slice
.y
== 0)
2291 y
+= s
->img
->vmargin
;
2293 if (s
->hl
== DRAW_IMAGE_SUNKEN
2294 || s
->hl
== DRAW_IMAGE_RAISED
)
2296 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2297 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2301 thick
= abs (s
->img
->relief
);
2302 raised_p
= s
->img
->relief
> 0;
2307 x1
= x
+ s
->slice
.width
+ thick
- 1;
2308 y1
= y
+ s
->slice
.height
+ thick
- 1;
2310 x_setup_relief_colors (s
);
2311 get_glyph_string_clip_rect (s
, &r
);
2312 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2314 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2316 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2321 /* Draw the foreground of image glyph string S to PIXMAP. */
2324 x_draw_image_foreground_1 (s
, pixmap
)
2325 struct glyph_string
*s
;
2329 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2331 /* If first glyph of S has a left box line, start drawing it to the
2332 right of that line. */
2333 if (s
->face
->box
!= FACE_NO_BOX
2334 && s
->first_glyph
->left_box_line_p
2336 x
+= abs (s
->face
->box_line_width
);
2338 /* If there is a margin around the image, adjust x- and y-position
2340 if (s
->slice
.x
== 0)
2341 x
+= s
->img
->hmargin
;
2342 if (s
->slice
.y
== 0)
2343 y
+= s
->img
->vmargin
;
2349 /* We can't set both a clip mask and use XSetClipRectangles
2350 because the latter also sets a clip mask. We also can't
2351 trust on the shape extension to be available
2352 (XShapeCombineRegion). So, compute the rectangle to draw
2354 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2358 xgcv
.clip_mask
= s
->img
->mask
;
2359 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2360 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2361 xgcv
.function
= GXcopy
;
2362 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2364 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2365 s
->slice
.x
, s
->slice
.y
,
2366 s
->slice
.width
, s
->slice
.height
, x
, y
);
2367 XSetClipMask (s
->display
, s
->gc
, None
);
2371 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2372 s
->slice
.x
, s
->slice
.y
,
2373 s
->slice
.width
, s
->slice
.height
, x
, y
);
2375 /* When the image has a mask, we can expect that at
2376 least part of a mouse highlight or a block cursor will
2377 be visible. If the image doesn't have a mask, make
2378 a block cursor visible by drawing a rectangle around
2379 the image. I believe it's looking better if we do
2380 nothing here for mouse-face. */
2381 if (s
->hl
== DRAW_CURSOR
)
2383 int r
= s
->img
->relief
;
2385 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2386 s
->slice
.width
+ r
*2 - 1,
2387 s
->slice
.height
+ r
*2 - 1);
2392 /* Draw a rectangle if image could not be loaded. */
2393 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2394 s
->slice
.width
- 1, s
->slice
.height
- 1);
2398 /* Draw part of the background of glyph string S. X, Y, W, and H
2399 give the rectangle to draw. */
2402 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2403 struct glyph_string
*s
;
2408 /* Fill background with a stipple pattern. */
2409 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2410 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2411 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2414 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2418 /* Draw image glyph string S.
2421 s->x +-------------------------
2424 | +-------------------------
2427 | | +-------------------
2433 x_draw_image_glyph_string (s
)
2434 struct glyph_string
*s
;
2436 int box_line_hwidth
= abs (s
->face
->box_line_width
);
2437 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2439 Pixmap pixmap
= None
;
2442 if (s
->slice
.y
== 0)
2443 height
-= box_line_vwidth
;
2444 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2445 height
-= box_line_vwidth
;
2447 /* Fill background with face under the image. Do it only if row is
2448 taller than image or if image has a clip mask to reduce
2450 s
->stippled_p
= s
->face
->stipple
!= 0;
2451 if (height
> s
->slice
.height
2455 || s
->img
->pixmap
== 0
2456 || s
->width
!= s
->background_width
)
2460 /* Create a pixmap as large as the glyph string. Fill it
2461 with the background color. Copy the image to it, using
2462 its mask. Copy the temporary pixmap to the display. */
2463 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2464 int depth
= DefaultDepthOfScreen (screen
);
2466 /* Create a pixmap as large as the glyph string. */
2467 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2468 s
->background_width
,
2471 /* Don't clip in the following because we're working on the
2473 XSetClipMask (s
->display
, s
->gc
, None
);
2475 /* Fill the pixmap with the background color/stipple. */
2478 /* Fill background with a stipple pattern. */
2479 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2480 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2481 0, 0, s
->background_width
, s
->height
);
2482 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2487 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2489 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2490 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2491 0, 0, s
->background_width
, s
->height
);
2492 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2500 if (s
->first_glyph
->left_box_line_p
2502 x
+= box_line_hwidth
;
2504 if (s
->slice
.y
== 0)
2505 y
+= box_line_vwidth
;
2507 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2510 s
->background_filled_p
= 1;
2513 /* Draw the foreground. */
2516 x_draw_image_foreground_1 (s
, pixmap
);
2517 x_set_glyph_string_clipping (s
);
2518 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2519 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2520 XFreePixmap (s
->display
, pixmap
);
2523 x_draw_image_foreground (s
);
2525 /* If we must draw a relief around the image, do it. */
2527 || s
->hl
== DRAW_IMAGE_RAISED
2528 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2529 x_draw_image_relief (s
);
2533 /* Draw stretch glyph string S. */
2536 x_draw_stretch_glyph_string (s
)
2537 struct glyph_string
*s
;
2539 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2540 s
->stippled_p
= s
->face
->stipple
!= 0;
2542 if (s
->hl
== DRAW_CURSOR
2543 && !x_stretch_cursor_p
)
2545 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2546 as wide as the stretch glyph. */
2547 int width
= min (FRAME_COLUMN_WIDTH (s
->f
), s
->background_width
);
2550 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
2552 /* Clear rest using the GC of the original non-cursor face. */
2553 if (width
< s
->background_width
)
2555 int x
= s
->x
+ width
, y
= s
->y
;
2556 int w
= s
->background_width
- width
, h
= s
->height
;
2560 if (s
->row
->mouse_face_p
2561 && cursor_in_mouse_face_p (s
->w
))
2563 x_set_mouse_face_gc (s
);
2569 get_glyph_string_clip_rect (s
, &r
);
2570 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2572 if (s
->face
->stipple
)
2574 /* Fill background with a stipple pattern. */
2575 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2576 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2577 XSetFillStyle (s
->display
, gc
, FillSolid
);
2582 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2583 XSetForeground (s
->display
, gc
, xgcv
.background
);
2584 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2585 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2589 else if (!s
->background_filled_p
)
2590 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
2593 s
->background_filled_p
= 1;
2597 /* Draw glyph string S. */
2600 x_draw_glyph_string (s
)
2601 struct glyph_string
*s
;
2603 int relief_drawn_p
= 0;
2605 /* If S draws into the background of its successor, draw the
2606 background of the successor first so that S can draw into it.
2607 This makes S->next use XDrawString instead of XDrawImageString. */
2608 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
2610 xassert (s
->next
->img
== NULL
);
2611 x_set_glyph_string_gc (s
->next
);
2612 x_set_glyph_string_clipping (s
->next
);
2613 x_draw_glyph_string_background (s
->next
, 1);
2616 /* Set up S->gc, set clipping and draw S. */
2617 x_set_glyph_string_gc (s
);
2619 /* Draw relief (if any) in advance for char/composition so that the
2620 glyph string can be drawn over it. */
2621 if (!s
->for_overlaps_p
2622 && s
->face
->box
!= FACE_NO_BOX
2623 && (s
->first_glyph
->type
== CHAR_GLYPH
2624 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2627 x_set_glyph_string_clipping (s
);
2628 x_draw_glyph_string_background (s
, 1);
2629 x_draw_glyph_string_box (s
);
2630 x_set_glyph_string_clipping (s
);
2634 x_set_glyph_string_clipping (s
);
2636 switch (s
->first_glyph
->type
)
2639 x_draw_image_glyph_string (s
);
2643 x_draw_stretch_glyph_string (s
);
2647 if (s
->for_overlaps_p
)
2648 s
->background_filled_p
= 1;
2650 x_draw_glyph_string_background (s
, 0);
2651 x_draw_glyph_string_foreground (s
);
2654 case COMPOSITE_GLYPH
:
2655 if (s
->for_overlaps_p
|| s
->gidx
> 0)
2656 s
->background_filled_p
= 1;
2658 x_draw_glyph_string_background (s
, 1);
2659 x_draw_composite_glyph_string_foreground (s
);
2666 if (!s
->for_overlaps_p
)
2668 /* Draw underline. */
2669 if (s
->face
->underline_p
)
2671 unsigned long tem
, h
;
2674 /* Get the underline thickness. Default is 1 pixel. */
2675 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
2678 /* Get the underline position. This is the recommended
2679 vertical offset in pixels from the baseline to the top of
2680 the underline. This is a signed value according to the
2681 specs, and its default is
2683 ROUND ((maximum descent) / 2), with
2684 ROUND(x) = floor (x + 0.5) */
2686 if (x_use_underline_position_properties
2687 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
2688 y
= s
->ybase
+ (long) tem
;
2689 else if (s
->face
->font
)
2690 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
2692 y
= s
->y
+ s
->height
- h
;
2694 if (s
->face
->underline_defaulted_p
)
2695 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2696 s
->x
, y
, s
->width
, h
);
2700 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2701 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2702 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2703 s
->x
, y
, s
->width
, h
);
2704 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2708 /* Draw overline. */
2709 if (s
->face
->overline_p
)
2711 unsigned long dy
= 0, h
= 1;
2713 if (s
->face
->overline_color_defaulted_p
)
2714 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2719 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2720 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2721 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2723 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2727 /* Draw strike-through. */
2728 if (s
->face
->strike_through_p
)
2730 unsigned long h
= 1;
2731 unsigned long dy
= (s
->height
- h
) / 2;
2733 if (s
->face
->strike_through_color_defaulted_p
)
2734 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2739 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2740 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2741 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2743 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2747 /* Draw relief if not yet drawn. */
2748 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2749 x_draw_glyph_string_box (s
);
2752 /* Reset clipping. */
2753 XSetClipMask (s
->display
, s
->gc
, None
);
2756 /* Shift display to make room for inserted glyphs. */
2759 x_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2761 int x
, y
, width
, height
, shift_by
;
2763 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2764 f
->output_data
.x
->normal_gc
,
2765 x
, y
, width
, height
,
2769 /* Delete N glyphs at the nominal cursor position. Not implemented
2780 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2781 If they are <= 0, this is probably an error. */
2784 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
2791 xassert (width
> 0 && height
> 0);
2792 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2796 /* Clear entire frame. If updating_frame is non-null, clear that
2797 frame. Otherwise clear the selected frame. */
2807 f
= SELECTED_FRAME ();
2809 /* Clearing the frame will erase any cursor, so mark them all as no
2811 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2812 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2813 output_cursor
.x
= -1;
2815 /* We don't set the output cursor here because there will always
2816 follow an explicit cursor_to. */
2818 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2820 /* We have to clear the scroll bars, too. If we have changed
2821 colors or something like that, then they should be notified. */
2822 x_scroll_bar_clear (f
);
2824 XFlush (FRAME_X_DISPLAY (f
));
2831 /* Invert the middle quarter of the frame for .15 sec. */
2833 /* We use the select system call to do the waiting, so we have to make
2834 sure it's available. If it isn't, we just won't do visual bells. */
2836 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2839 /* Subtract the `struct timeval' values X and Y, storing the result in
2840 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2843 timeval_subtract (result
, x
, y
)
2844 struct timeval
*result
, x
, y
;
2846 /* Perform the carry for the later subtraction by updating y. This
2847 is safer because on some systems the tv_sec member is unsigned. */
2848 if (x
.tv_usec
< y
.tv_usec
)
2850 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2851 y
.tv_usec
-= 1000000 * nsec
;
2855 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2857 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2858 y
.tv_usec
+= 1000000 * nsec
;
2862 /* Compute the time remaining to wait. tv_usec is certainly
2864 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2865 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2867 /* Return indication of whether the result should be considered
2869 return x
.tv_sec
< y
.tv_sec
;
2881 /* Create a GC that will use the GXxor function to flip foreground
2882 pixels into background pixels. */
2886 values
.function
= GXxor
;
2887 values
.foreground
= (f
->output_data
.x
->foreground_pixel
2888 ^ f
->output_data
.x
->background_pixel
);
2890 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2891 GCFunction
| GCForeground
, &values
);
2895 /* Get the height not including a menu bar widget. */
2896 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
2897 /* Height of each line to flash. */
2898 int flash_height
= FRAME_LINE_HEIGHT (f
);
2899 /* These will be the left and right margins of the rectangles. */
2900 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
2901 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
2905 /* Don't flash the area between a scroll bar and the frame
2906 edge it is next to. */
2907 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
2909 case vertical_scroll_bar_left
:
2910 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2913 case vertical_scroll_bar_right
:
2914 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2921 width
= flash_right
- flash_left
;
2923 /* If window is tall, flash top and bottom line. */
2924 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2926 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2928 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2929 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
2930 width
, flash_height
);
2931 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2933 (height
- flash_height
2934 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2935 width
, flash_height
);
2938 /* If it is short, flash it all. */
2939 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2940 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
2941 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
2946 struct timeval wakeup
;
2948 EMACS_GET_TIME (wakeup
);
2950 /* Compute time to wait until, propagating carry from usecs. */
2951 wakeup
.tv_usec
+= 150000;
2952 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
2953 wakeup
.tv_usec
%= 1000000;
2955 /* Keep waiting until past the time wakeup or any input gets
2957 while (! detect_input_pending ())
2959 struct timeval current
;
2960 struct timeval timeout
;
2962 EMACS_GET_TIME (current
);
2964 /* Break if result would be negative. */
2965 if (timeval_subtract (¤t
, wakeup
, current
))
2968 /* How long `select' should wait. */
2970 timeout
.tv_usec
= 10000;
2972 /* Try to wait that long--but we might wake up sooner. */
2973 select (0, NULL
, NULL
, NULL
, &timeout
);
2977 /* If window is tall, flash top and bottom line. */
2978 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2980 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2982 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2983 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
2984 width
, flash_height
);
2985 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2987 (height
- flash_height
2988 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2989 width
, flash_height
);
2992 /* If it is short, flash it all. */
2993 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2994 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
2995 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
2997 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3005 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3008 /* Make audible bell. */
3013 struct frame
*f
= SELECTED_FRAME ();
3015 if (FRAME_X_DISPLAY (f
))
3017 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3024 XBell (FRAME_X_DISPLAY (f
), 0);
3025 XFlush (FRAME_X_DISPLAY (f
));
3032 /* Specify how many text lines, from the top of the window,
3033 should be affected by insert-lines and delete-lines operations.
3034 This, and those operations, are used only within an update
3035 that is bounded by calls to x_update_begin and x_update_end. */
3038 XTset_terminal_window (n
)
3041 /* This function intentionally left blank. */
3046 /***********************************************************************
3048 ***********************************************************************/
3050 /* Perform an insert-lines or delete-lines operation, inserting N
3051 lines or deleting -N lines at vertical position VPOS. */
3054 x_ins_del_lines (vpos
, n
)
3061 /* Scroll part of the display as described by RUN. */
3064 x_scroll_run (w
, run
)
3068 struct frame
*f
= XFRAME (w
->frame
);
3069 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3071 /* Get frame-relative bounding box of the text display area of W,
3072 without mode lines. Include in this box the left and right
3074 window_box (w
, -1, &x
, &y
, &width
, &height
);
3076 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3077 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3078 bottom_y
= y
+ height
;
3082 /* Scrolling up. Make sure we don't copy part of the mode
3083 line at the bottom. */
3084 if (from_y
+ run
->height
> bottom_y
)
3085 height
= bottom_y
- from_y
;
3087 height
= run
->height
;
3091 /* Scolling down. Make sure we don't copy over the mode line.
3093 if (to_y
+ run
->height
> bottom_y
)
3094 height
= bottom_y
- to_y
;
3096 height
= run
->height
;
3101 /* Cursor off. Will be switched on again in x_update_window_end. */
3105 XCopyArea (FRAME_X_DISPLAY (f
),
3106 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3107 f
->output_data
.x
->normal_gc
,
3117 /***********************************************************************
3119 ***********************************************************************/
3126 /* We used to only do this if Vx_no_window_manager was non-nil, but
3127 the ICCCM (section 4.1.6) says that the window's border pixmap
3128 and border pixel are window attributes which are "private to the
3129 client", so we can always change it to whatever we want. */
3131 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3132 f
->output_data
.x
->border_pixel
);
3134 x_update_cursor (f
, 1);
3138 frame_unhighlight (f
)
3141 /* We used to only do this if Vx_no_window_manager was non-nil, but
3142 the ICCCM (section 4.1.6) says that the window's border pixmap
3143 and border pixel are window attributes which are "private to the
3144 client", so we can always change it to whatever we want. */
3146 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3147 f
->output_data
.x
->border_tile
);
3149 x_update_cursor (f
, 1);
3152 /* The focus has changed. Update the frames as necessary to reflect
3153 the new situation. Note that we can't change the selected frame
3154 here, because the Lisp code we are interrupting might become confused.
3155 Each event gets marked with the frame in which it occurred, so the
3156 Lisp code can tell when the switch took place by examining the events. */
3159 x_new_focus_frame (dpyinfo
, frame
)
3160 struct x_display_info
*dpyinfo
;
3161 struct frame
*frame
;
3163 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3165 if (frame
!= dpyinfo
->x_focus_frame
)
3167 /* Set this before calling other routines, so that they see
3168 the correct value of x_focus_frame. */
3169 dpyinfo
->x_focus_frame
= frame
;
3171 if (old_focus
&& old_focus
->auto_lower
)
3172 x_lower_frame (old_focus
);
3175 selected_frame
= frame
;
3176 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
3178 Fselect_window (selected_frame
->selected_window
, Qnil
);
3179 choose_minibuf_frame ();
3182 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3183 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3185 pending_autoraise_frame
= 0;
3188 x_frame_rehighlight (dpyinfo
);
3191 /* Handle FocusIn and FocusOut state changes for FRAME.
3192 If FRAME has focus and there exists more than one frame, puts
3193 a FOCUS_IN_EVENT into *BUFP. */
3196 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
3199 struct x_display_info
*dpyinfo
;
3200 struct frame
*frame
;
3201 struct input_event
*bufp
;
3203 if (type
== FocusIn
)
3205 if (dpyinfo
->x_focus_event_frame
!= frame
)
3207 x_new_focus_frame (dpyinfo
, frame
);
3208 dpyinfo
->x_focus_event_frame
= frame
;
3210 /* Don't stop displaying the initial startup message
3211 for a switch-frame event we don't need. */
3212 if (GC_NILP (Vterminal_frame
)
3213 && GC_CONSP (Vframe_list
)
3214 && !GC_NILP (XCDR (Vframe_list
)))
3216 bufp
->kind
= FOCUS_IN_EVENT
;
3217 XSETFRAME (bufp
->frame_or_window
, frame
);
3221 frame
->output_data
.x
->focus_state
|= state
;
3224 if (FRAME_XIC (frame
))
3225 XSetICFocus (FRAME_XIC (frame
));
3228 else if (type
== FocusOut
)
3230 frame
->output_data
.x
->focus_state
&= ~state
;
3232 if (dpyinfo
->x_focus_event_frame
== frame
)
3234 dpyinfo
->x_focus_event_frame
= 0;
3235 x_new_focus_frame (dpyinfo
, 0);
3239 if (FRAME_XIC (frame
))
3240 XUnsetICFocus (FRAME_XIC (frame
));
3245 /* The focus may have changed. Figure out if it is a real focus change,
3246 by checking both FocusIn/Out and Enter/LeaveNotify events.
3248 Returns FOCUS_IN_EVENT event in *BUFP. */
3251 x_detect_focus_change (dpyinfo
, event
, bufp
)
3252 struct x_display_info
*dpyinfo
;
3254 struct input_event
*bufp
;
3256 struct frame
*frame
;
3258 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3262 switch (event
->type
)
3267 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3269 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3271 if (event
->xcrossing
.detail
!= NotifyInferior
3272 && event
->xcrossing
.focus
3273 && ! (focus_state
& FOCUS_EXPLICIT
))
3274 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3276 dpyinfo
, frame
, bufp
);
3282 x_focus_changed (event
->type
,
3283 (event
->xfocus
.detail
== NotifyPointer
?
3284 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3285 dpyinfo
, frame
, bufp
);
3291 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3294 x_mouse_leave (dpyinfo
)
3295 struct x_display_info
*dpyinfo
;
3297 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3300 /* The focus has changed, or we have redirected a frame's focus to
3301 another frame (this happens when a frame uses a surrogate
3302 mini-buffer frame). Shift the highlight as appropriate.
3304 The FRAME argument doesn't necessarily have anything to do with which
3305 frame is being highlighted or un-highlighted; we only use it to find
3306 the appropriate X display info. */
3309 XTframe_rehighlight (frame
)
3310 struct frame
*frame
;
3312 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3316 x_frame_rehighlight (dpyinfo
)
3317 struct x_display_info
*dpyinfo
;
3319 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3321 if (dpyinfo
->x_focus_frame
)
3323 dpyinfo
->x_highlight_frame
3324 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3325 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3326 : dpyinfo
->x_focus_frame
);
3327 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3329 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3330 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3334 dpyinfo
->x_highlight_frame
= 0;
3336 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3339 frame_unhighlight (old_highlight
);
3340 if (dpyinfo
->x_highlight_frame
)
3341 frame_highlight (dpyinfo
->x_highlight_frame
);
3347 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3349 /* Initialize mode_switch_bit and modifier_meaning. */
3351 x_find_modifier_meanings (dpyinfo
)
3352 struct x_display_info
*dpyinfo
;
3354 int min_code
, max_code
;
3357 XModifierKeymap
*mods
;
3359 dpyinfo
->meta_mod_mask
= 0;
3360 dpyinfo
->shift_lock_mask
= 0;
3361 dpyinfo
->alt_mod_mask
= 0;
3362 dpyinfo
->super_mod_mask
= 0;
3363 dpyinfo
->hyper_mod_mask
= 0;
3366 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3368 min_code
= dpyinfo
->display
->min_keycode
;
3369 max_code
= dpyinfo
->display
->max_keycode
;
3372 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3373 min_code
, max_code
- min_code
+ 1,
3375 mods
= XGetModifierMapping (dpyinfo
->display
);
3377 /* Scan the modifier table to see which modifier bits the Meta and
3378 Alt keysyms are on. */
3380 int row
, col
; /* The row and column in the modifier table. */
3381 int found_alt_or_meta
;
3383 for (row
= 3; row
< 8; row
++)
3385 found_alt_or_meta
= 0;
3386 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3388 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3390 /* Zeroes are used for filler. Skip them. */
3394 /* Are any of this keycode's keysyms a meta key? */
3398 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3400 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3406 found_alt_or_meta
= 1;
3407 dpyinfo
->meta_mod_mask
|= (1 << row
);
3412 found_alt_or_meta
= 1;
3413 dpyinfo
->alt_mod_mask
|= (1 << row
);
3418 if (!found_alt_or_meta
)
3419 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3420 code_col
= syms_per_code
;
3421 col
= mods
->max_keypermod
;
3426 if (!found_alt_or_meta
)
3427 dpyinfo
->super_mod_mask
|= (1 << row
);
3428 code_col
= syms_per_code
;
3429 col
= mods
->max_keypermod
;
3433 /* Ignore this if it's not on the lock modifier. */
3434 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3435 dpyinfo
->shift_lock_mask
= LockMask
;
3436 code_col
= syms_per_code
;
3437 col
= mods
->max_keypermod
;
3446 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3447 if (! dpyinfo
->meta_mod_mask
)
3449 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3450 dpyinfo
->alt_mod_mask
= 0;
3453 /* If some keys are both alt and meta,
3454 make them just meta, not alt. */
3455 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3457 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3460 XFree ((char *) syms
);
3461 XFreeModifiermap (mods
);
3464 /* Convert between the modifier bits X uses and the modifier bits
3468 x_x_to_emacs_modifiers (dpyinfo
, state
)
3469 struct x_display_info
*dpyinfo
;
3472 EMACS_UINT mod_meta
= meta_modifier
;
3473 EMACS_UINT mod_alt
= alt_modifier
;
3474 EMACS_UINT mod_hyper
= hyper_modifier
;
3475 EMACS_UINT mod_super
= super_modifier
;
3478 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3479 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3480 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3481 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3482 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3483 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3484 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3485 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3488 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3489 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3490 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3491 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3492 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3493 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3497 x_emacs_to_x_modifiers (dpyinfo
, state
)
3498 struct x_display_info
*dpyinfo
;
3501 EMACS_UINT mod_meta
= meta_modifier
;
3502 EMACS_UINT mod_alt
= alt_modifier
;
3503 EMACS_UINT mod_hyper
= hyper_modifier
;
3504 EMACS_UINT mod_super
= super_modifier
;
3508 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3509 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3510 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3511 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3512 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3513 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3514 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3515 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3518 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3519 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3520 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3521 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3522 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3523 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3526 /* Convert a keysym to its name. */
3529 x_get_keysym_name (keysym
)
3535 value
= XKeysymToString (keysym
);
3543 /* Mouse clicks and mouse movement. Rah. */
3545 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3547 If the event is a button press, then note that we have grabbed
3551 construct_mouse_click (result
, event
, f
)
3552 struct input_event
*result
;
3553 XButtonEvent
*event
;
3556 /* Make the event type NO_EVENT; we'll change that when we decide
3558 result
->kind
= MOUSE_CLICK_EVENT
;
3559 result
->code
= event
->button
- Button1
;
3560 result
->timestamp
= event
->time
;
3561 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3563 | (event
->type
== ButtonRelease
3567 XSETINT (result
->x
, event
->x
);
3568 XSETINT (result
->y
, event
->y
);
3569 XSETFRAME (result
->frame_or_window
, f
);
3575 /* Function to report a mouse movement to the mainstream Emacs code.
3576 The input handler calls this.
3578 We have received a mouse movement event, which is given in *event.
3579 If the mouse is over a different glyph than it was last time, tell
3580 the mainstream emacs code by setting mouse_moved. If not, ask for
3581 another motion event, so we can check again the next time it moves. */
3583 static XMotionEvent last_mouse_motion_event
;
3584 static Lisp_Object last_mouse_motion_frame
;
3587 note_mouse_movement (frame
, event
)
3589 XMotionEvent
*event
;
3591 last_mouse_movement_time
= event
->time
;
3592 last_mouse_motion_event
= *event
;
3593 XSETFRAME (last_mouse_motion_frame
, frame
);
3595 if (event
->window
!= FRAME_X_WINDOW (frame
))
3597 frame
->mouse_moved
= 1;
3598 last_mouse_scroll_bar
= Qnil
;
3599 note_mouse_highlight (frame
, -1, -1);
3602 /* Has the mouse moved off the glyph it was on at the last sighting? */
3603 else if (event
->x
< last_mouse_glyph
.x
3604 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3605 || event
->y
< last_mouse_glyph
.y
3606 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3608 frame
->mouse_moved
= 1;
3609 last_mouse_scroll_bar
= Qnil
;
3610 note_mouse_highlight (frame
, event
->x
, event
->y
);
3615 /************************************************************************
3617 ************************************************************************/
3620 redo_mouse_highlight ()
3622 if (!NILP (last_mouse_motion_frame
)
3623 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3624 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3625 last_mouse_motion_event
.x
,
3626 last_mouse_motion_event
.y
);
3630 static int glyph_rect
P_ ((struct frame
*f
, int, int, XRectangle
*));
3633 /* Try to determine frame pixel position and size of the glyph under
3634 frame pixel coordinates X/Y on frame F . Return the position and
3635 size in *RECT. Value is non-zero if we could compute these
3639 glyph_rect (f
, x
, y
, rect
)
3646 struct glyph_row
*r
, *end_row
;
3648 window
= window_from_coordinates (f
, x
, y
, 0, &x
, &y
, 0);
3652 w
= XWINDOW (window
);
3653 r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
3654 end_row
= r
+ w
->current_matrix
->nrows
- 1;
3656 for (; r
< end_row
&& r
->enabled_p
; ++r
)
3660 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
3661 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
3663 while (g
< end
&& gx
< x
)
3664 gx
+= g
->pixel_width
, ++g
;
3667 rect
->width
= g
->pixel_width
;
3668 rect
->height
= r
->height
;
3669 rect
->x
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
3670 rect
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
3681 /* Return the current position of the mouse.
3682 *FP should be a frame which indicates which display to ask about.
3684 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3685 and *PART to the frame, window, and scroll bar part that the mouse
3686 is over. Set *X and *Y to the portion and whole of the mouse's
3687 position on the scroll bar.
3689 If the mouse movement started elsewhere, set *FP to the frame the
3690 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3693 Set *TIME to the server time-stamp for the time at which the mouse
3694 was at this position.
3696 Don't store anything if we don't have a valid set of values to report.
3698 This clears the mouse_moved flag, so we can wait for the next mouse
3702 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3705 Lisp_Object
*bar_window
;
3706 enum scroll_bar_part
*part
;
3708 unsigned long *time
;
3714 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3715 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3721 Window dummy_window
;
3724 Lisp_Object frame
, tail
;
3726 /* Clear the mouse-moved flag for every frame on this display. */
3727 FOR_EACH_FRAME (tail
, frame
)
3728 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3729 XFRAME (frame
)->mouse_moved
= 0;
3731 last_mouse_scroll_bar
= Qnil
;
3733 /* Figure out which root window we're on. */
3734 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3735 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3737 /* The root window which contains the pointer. */
3740 /* Trash which we can't trust if the pointer is on
3741 a different screen. */
3744 /* The position on that root window. */
3747 /* More trash we can't trust. */
3750 /* Modifier keys and pointer buttons, about which
3752 (unsigned int *) &dummy
);
3754 /* Now we have a position on the root; find the innermost window
3755 containing the pointer. */
3759 int parent_x
= 0, parent_y
= 0;
3764 /* XTranslateCoordinates can get errors if the window
3765 structure is changing at the same time this function
3766 is running. So at least we must not crash from them. */
3768 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
3770 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3771 && FRAME_LIVE_P (last_mouse_frame
))
3773 /* If mouse was grabbed on a frame, give coords for that frame
3774 even if the mouse is now outside it. */
3775 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3777 /* From-window, to-window. */
3778 root
, FRAME_X_WINDOW (last_mouse_frame
),
3780 /* From-position, to-position. */
3781 root_x
, root_y
, &win_x
, &win_y
,
3785 f1
= last_mouse_frame
;
3791 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3793 /* From-window, to-window. */
3796 /* From-position, to-position. */
3797 root_x
, root_y
, &win_x
, &win_y
,
3802 if (child
== None
|| child
== win
)
3810 /* Now we know that:
3811 win is the innermost window containing the pointer
3812 (XTC says it has no child containing the pointer),
3813 win_x and win_y are the pointer's position in it
3814 (XTC did this the last time through), and
3815 parent_x and parent_y are the pointer's position in win's parent.
3816 (They are what win_x and win_y were when win was child.
3817 If win is the root window, it has no parent, and
3818 parent_{x,y} are invalid, but that's okay, because we'll
3819 never use them in that case.) */
3821 /* Is win one of our frames? */
3822 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3824 #ifdef USE_X_TOOLKIT
3825 /* If we end up with the menu bar window, say it's not
3828 && f1
->output_data
.x
->menubar_widget
3829 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3831 #endif /* USE_X_TOOLKIT */
3834 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3837 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
3839 /* If not, is it one of our scroll bars? */
3842 struct scroll_bar
*bar
;
3844 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3848 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3854 if (f1
== 0 && insist
> 0)
3855 f1
= SELECTED_FRAME ();
3859 /* Ok, we found a frame. Store all the values.
3860 last_mouse_glyph is a rectangle used to reduce the
3861 generation of mouse events. To not miss any motion
3862 events, we must divide the frame into rectangles of the
3863 size of the smallest character that could be displayed
3864 on it, i.e. into the same rectangles that matrices on
3865 the frame are divided into. */
3867 int width
, height
, gx
, gy
;
3870 if (glyph_rect (f1
, win_x
, win_y
, &rect
))
3871 last_mouse_glyph
= rect
;
3874 width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
3875 height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
3879 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
3880 round down even for negative values. */
3885 gx
= (gx
+ width
- 1) / width
* width
;
3886 gy
= (gy
+ height
- 1) / height
* height
;
3888 last_mouse_glyph
.width
= width
;
3889 last_mouse_glyph
.height
= height
;
3890 last_mouse_glyph
.x
= gx
;
3891 last_mouse_glyph
.y
= gy
;
3897 XSETINT (*x
, win_x
);
3898 XSETINT (*y
, win_y
);
3899 *time
= last_mouse_movement_time
;
3909 /***********************************************************************
3911 ***********************************************************************/
3913 /* Scroll bar support. */
3915 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3917 This can be called in GC, so we have to make sure to strip off mark
3920 static struct scroll_bar
*
3921 x_window_to_scroll_bar (display
, window_id
)
3928 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3929 #endif /* USE_GTK */
3931 for (tail
= Vframe_list
;
3932 XGCTYPE (tail
) == Lisp_Cons
;
3935 Lisp_Object frame
, bar
, condemned
;
3937 frame
= XCAR (tail
);
3938 /* All elements of Vframe_list should be frames. */
3939 if (! GC_FRAMEP (frame
))
3942 /* Scan this frame's scroll bar list for a scroll bar with the
3944 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3945 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3946 /* This trick allows us to search both the ordinary and
3947 condemned scroll bar lists with one loop. */
3948 ! GC_NILP (bar
) || (bar
= condemned
,
3951 bar
= XSCROLL_BAR (bar
)->next
)
3952 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
&&
3953 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
3954 return XSCROLL_BAR (bar
);
3961 #if defined USE_LUCID
3963 /* Return the Lucid menu bar WINDOW is part of. Return null
3964 if WINDOW is not part of a menu bar. */
3967 x_window_to_menu_bar (window
)
3972 for (tail
= Vframe_list
;
3973 XGCTYPE (tail
) == Lisp_Cons
;
3976 Lisp_Object frame
= XCAR (tail
);
3977 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
3979 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
3986 #endif /* USE_LUCID */
3989 /************************************************************************
3991 ************************************************************************/
3993 #ifdef USE_TOOLKIT_SCROLL_BARS
3995 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
3996 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
3997 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
3998 struct scroll_bar
*));
3999 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
4003 /* Lisp window being scrolled. Set when starting to interact with
4004 a toolkit scroll bar, reset to nil when ending the interaction. */
4006 static Lisp_Object window_being_scrolled
;
4008 /* Last scroll bar part sent in xm_scroll_callback. */
4010 static int last_scroll_bar_part
;
4012 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4013 that movements of 1/20 of the screen size are mapped to up/down. */
4016 /* Id of action hook installed for scroll bars. */
4018 static XtActionHookId action_hook_id
;
4020 static Boolean xaw3d_arrow_scroll
;
4022 /* Whether the drag scrolling maintains the mouse at the top of the
4023 thumb. If not, resizing the thumb needs to be done more carefully
4024 to avoid jerkyness. */
4026 static Boolean xaw3d_pick_top
;
4028 extern void set_vertical_scroll_bar
P_ ((struct window
*));
4030 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4031 bars are used.. The hook is responsible for detecting when
4032 the user ends an interaction with the scroll bar, and generates
4033 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4036 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
4039 XtPointer client_data
;
4043 Cardinal
*num_params
;
4049 scroll_bar_p
= XmIsScrollBar (widget
);
4050 end_action
= "Release";
4051 #else /* !USE_MOTIF i.e. use Xaw */
4052 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4053 end_action
= "EndScroll";
4054 #endif /* USE_MOTIF */
4057 && strcmp (action_name
, end_action
) == 0
4058 && WINDOWP (window_being_scrolled
))
4062 x_send_scroll_bar_event (window_being_scrolled
,
4063 scroll_bar_end_scroll
, 0, 0);
4064 w
= XWINDOW (window_being_scrolled
);
4066 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4068 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4069 /* The thumb size is incorrect while dragging: fix it. */
4070 set_vertical_scroll_bar (w
);
4072 window_being_scrolled
= Qnil
;
4073 last_scroll_bar_part
= -1;
4075 /* Xt timeouts no longer needed. */
4076 toolkit_scroll_bar_interaction
= 0;
4079 #endif /* not USE_GTK */
4081 /* A vector of windows used for communication between
4082 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4084 static struct window
**scroll_bar_windows
;
4085 static int scroll_bar_windows_size
;
4088 /* Send a client message with message type Xatom_Scrollbar for a
4089 scroll action to the frame of WINDOW. PART is a value identifying
4090 the part of the scroll bar that was clicked on. PORTION is the
4091 amount to scroll of a whole of WHOLE. */
4094 x_send_scroll_bar_event (window
, part
, portion
, whole
)
4096 int part
, portion
, whole
;
4099 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4100 struct window
*w
= XWINDOW (window
);
4101 struct frame
*f
= XFRAME (w
->frame
);
4106 /* Construct a ClientMessage event to send to the frame. */
4107 ev
->type
= ClientMessage
;
4108 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4109 ev
->display
= FRAME_X_DISPLAY (f
);
4110 ev
->window
= FRAME_X_WINDOW (f
);
4113 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4114 not enough to store a pointer or Lisp_Object on a 64 bit system.
4115 So, store the window in scroll_bar_windows and pass the index
4116 into that array in the event. */
4117 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4118 if (scroll_bar_windows
[i
] == NULL
)
4121 if (i
== scroll_bar_windows_size
)
4123 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4124 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4125 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4127 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4129 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
4130 scroll_bar_windows_size
= new_size
;
4133 scroll_bar_windows
[i
] = w
;
4134 ev
->data
.l
[0] = (long) i
;
4135 ev
->data
.l
[1] = (long) part
;
4136 ev
->data
.l
[2] = (long) 0;
4137 ev
->data
.l
[3] = (long) portion
;
4138 ev
->data
.l
[4] = (long) whole
;
4140 /* Make Xt timeouts work while the scroll bar is active. */
4141 toolkit_scroll_bar_interaction
= 1;
4143 /* Setting the event mask to zero means that the message will
4144 be sent to the client that created the window, and if that
4145 window no longer exists, no event will be sent. */
4146 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4151 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4155 x_scroll_bar_to_input_event (event
, ievent
)
4157 struct input_event
*ievent
;
4159 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4164 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4165 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4167 XSETWINDOW (window
, w
);
4168 f
= XFRAME (w
->frame
);
4170 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4171 ievent
->frame_or_window
= window
;
4174 ievent
->timestamp
= CurrentTime
;
4176 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4178 ievent
->part
= ev
->data
.l
[1];
4179 ievent
->code
= ev
->data
.l
[2];
4180 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4181 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4182 ievent
->modifiers
= 0;
4188 /* Minimum and maximum values used for Motif scroll bars. */
4190 #define XM_SB_MAX 10000000
4193 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4194 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4195 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4198 xm_scroll_callback (widget
, client_data
, call_data
)
4200 XtPointer client_data
, call_data
;
4202 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4203 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4204 int part
= -1, whole
= 0, portion
= 0;
4208 case XmCR_DECREMENT
:
4209 bar
->dragging
= Qnil
;
4210 part
= scroll_bar_up_arrow
;
4213 case XmCR_INCREMENT
:
4214 bar
->dragging
= Qnil
;
4215 part
= scroll_bar_down_arrow
;
4218 case XmCR_PAGE_DECREMENT
:
4219 bar
->dragging
= Qnil
;
4220 part
= scroll_bar_above_handle
;
4223 case XmCR_PAGE_INCREMENT
:
4224 bar
->dragging
= Qnil
;
4225 part
= scroll_bar_below_handle
;
4229 bar
->dragging
= Qnil
;
4230 part
= scroll_bar_to_top
;
4233 case XmCR_TO_BOTTOM
:
4234 bar
->dragging
= Qnil
;
4235 part
= scroll_bar_to_bottom
;
4242 /* Get the slider size. */
4244 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4247 whole
= XM_SB_MAX
- slider_size
;
4248 portion
= min (cs
->value
, whole
);
4249 part
= scroll_bar_handle
;
4250 bar
->dragging
= make_number (cs
->value
);
4254 case XmCR_VALUE_CHANGED
:
4260 window_being_scrolled
= bar
->window
;
4261 last_scroll_bar_part
= part
;
4262 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4267 #else /* !USE_MOTIF, i.e. Xaw or GTK */
4269 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4270 bar widget. DATA is a pointer to the scroll_bar structure. */
4273 xg_scroll_callback (widget
, data
)
4277 struct scroll_bar
*bar
= (struct scroll_bar
*) data
;
4283 int part
= -1, whole
= 0, portion
= 0;
4284 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (widget
));
4286 if (xg_ignore_gtk_scrollbar
) return;
4288 position
= gtk_adjustment_get_value (adj
);
4290 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
4293 p
= (gdouble
*) xmalloc (sizeof (gdouble
));
4295 g_object_set_data (G_OBJECT (widget
), XG_LAST_SB_DATA
, p
);
4301 diff
= (int) (position
- previous
);
4303 if (diff
== (int) adj
->step_increment
)
4305 part
= scroll_bar_down_arrow
;
4306 bar
->dragging
= Qnil
;
4308 else if (-diff
== (int) adj
->step_increment
)
4310 part
= scroll_bar_up_arrow
;
4311 bar
->dragging
= Qnil
;
4313 else if (diff
== (int) adj
->page_increment
)
4315 part
= scroll_bar_below_handle
;
4316 bar
->dragging
= Qnil
;
4318 else if (-diff
== (int) adj
->page_increment
)
4320 part
= scroll_bar_above_handle
;
4321 bar
->dragging
= Qnil
;
4325 part
= scroll_bar_handle
;
4326 whole
= adj
->upper
- adj
->page_size
;
4327 portion
= min ((int)position
, whole
);
4328 bar
->dragging
= make_number ((int)portion
);
4333 window_being_scrolled
= bar
->window
;
4334 last_scroll_bar_part
= part
;
4335 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4339 #else /* not USE_GTK */
4341 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4342 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4343 scroll bar struct. CALL_DATA is a pointer to a float saying where
4347 xaw_jump_callback (widget
, client_data
, call_data
)
4349 XtPointer client_data
, call_data
;
4351 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4352 float top
= *(float *) call_data
;
4354 int whole
, portion
, height
;
4357 /* Get the size of the thumb, a value between 0 and 1. */
4359 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4363 portion
= shown
< 1 ? top
* whole
: 0;
4365 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
4366 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4367 the bottom, so we force the scrolling whenever we see that we're
4368 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4369 we try to ensure that we always stay two pixels away from the
4371 part
= scroll_bar_down_arrow
;
4373 part
= scroll_bar_handle
;
4375 window_being_scrolled
= bar
->window
;
4376 bar
->dragging
= make_number (portion
);
4377 last_scroll_bar_part
= part
;
4378 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4382 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4383 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4384 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4385 the scroll bar. CALL_DATA is an integer specifying the action that
4386 has taken place. Its magnitude is in the range 0..height of the
4387 scroll bar. Negative values mean scroll towards buffer start.
4388 Values < height of scroll bar mean line-wise movement. */
4391 xaw_scroll_callback (widget
, client_data
, call_data
)
4393 XtPointer client_data
, call_data
;
4395 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4396 /* The position really is stored cast to a pointer. */
4397 int position
= (long) call_data
;
4401 /* Get the height of the scroll bar. */
4403 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4406 if (abs (position
) >= height
)
4407 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4409 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4410 it maps line-movement to call_data = max(5, height/20). */
4411 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
4412 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4414 part
= scroll_bar_move_ratio
;
4416 window_being_scrolled
= bar
->window
;
4417 bar
->dragging
= Qnil
;
4418 last_scroll_bar_part
= part
;
4419 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4422 #endif /* not USE_GTK */
4423 #endif /* not USE_MOTIF */
4425 #define SCROLL_BAR_NAME "verticalScrollBar"
4427 /* Create the widget for scroll bar BAR on frame F. Record the widget
4428 and X window of the scroll bar in BAR. */
4432 x_create_toolkit_scroll_bar (f
, bar
)
4434 struct scroll_bar
*bar
;
4436 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4439 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4444 #else /* not USE_GTK */
4447 x_create_toolkit_scroll_bar (f
, bar
)
4449 struct scroll_bar
*bar
;
4455 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4456 unsigned long pixel
;
4461 /* Set resources. Create the widget. */
4462 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4463 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4464 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4465 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4466 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4467 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4468 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4470 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4473 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4477 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4480 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4484 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4485 scroll_bar_name
, av
, ac
);
4487 /* Add one callback for everything that can happen. */
4488 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4490 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4492 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4494 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4496 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4498 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4500 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4503 /* Realize the widget. Only after that is the X window created. */
4504 XtRealizeWidget (widget
);
4506 /* Set the cursor to an arrow. I didn't find a resource to do that.
4507 And I'm wondering why it hasn't an arrow cursor by default. */
4508 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4509 f
->output_data
.x
->nontext_cursor
);
4511 #else /* !USE_MOTIF i.e. use Xaw */
4513 /* Set resources. Create the widget. The background of the
4514 Xaw3d scroll bar widget is a little bit light for my taste.
4515 We don't alter it here to let users change it according
4516 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4517 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4518 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4519 /* For smoother scrolling with Xaw3d -sm */
4520 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4522 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4525 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4529 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4532 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4536 /* Top/bottom shadow colors. */
4538 /* Allocate them, if necessary. */
4539 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4541 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4542 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4543 &pixel
, 1.2, 0x8000))
4545 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4547 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4549 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4550 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4551 &pixel
, 0.6, 0x4000))
4553 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4556 /* Tell the toolkit about them. */
4557 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4558 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4559 /* We tried to allocate a color for the top/bottom shadow, and
4560 failed, so tell Xaw3d to use dithering instead. */
4562 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
4566 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4567 be more consistent with other emacs 3d colors, and since Xaw3d is
4568 not good at dealing with allocation failure. */
4570 /* This tells Xaw3d to use real colors instead of dithering for
4572 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4575 /* Specify the colors. */
4576 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4579 XtSetArg (av
[ac
], "topShadowPixel", pixel
);
4582 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4585 XtSetArg (av
[ac
], "bottomShadowPixel", pixel
);
4590 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4591 f
->output_data
.x
->edit_widget
, av
, ac
);
4595 char *val
= initial
;
4596 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4597 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4599 { /* ARROW_SCROLL */
4600 xaw3d_arrow_scroll
= True
;
4601 /* Isn't that just a personal preference ? -sm */
4602 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4606 /* Define callbacks. */
4607 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4608 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4611 /* Realize the widget. Only after that is the X window created. */
4612 XtRealizeWidget (widget
);
4614 #endif /* !USE_MOTIF */
4616 /* Install an action hook that lets us detect when the user
4617 finishes interacting with a scroll bar. */
4618 if (action_hook_id
== 0)
4619 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4621 /* Remember X window and widget in the scroll bar vector. */
4622 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4623 xwindow
= XtWindow (widget
);
4624 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
4628 #endif /* not USE_GTK */
4631 /* Set the thumb size and position of scroll bar BAR. We are currently
4632 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4636 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4637 struct scroll_bar
*bar
;
4638 int portion
, position
, whole
;
4640 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4643 #else /* not USE_GTK */
4645 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4646 struct scroll_bar
*bar
;
4647 int portion
, position
, whole
;
4649 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4650 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4657 /* We use an estimate of 30 chars per line rather than the real
4658 `portion' value. This has the disadvantage that the thumb size
4659 is not very representative, but it makes our life a lot easier.
4660 Otherwise, we have to constantly adjust the thumb size, which
4661 we can't always do quickly enough: while dragging, the size of
4662 the thumb might prevent the user from dragging the thumb all the
4663 way to the end. but Motif and some versions of Xaw3d don't allow
4664 updating the thumb size while dragging. Also, even if we can update
4665 its size, the update will often happen too late.
4666 If you don't believe it, check out revision 1.650 of xterm.c to see
4667 what hoops we were going through and the still poor behavior we got. */
4668 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4669 /* When the thumb is at the bottom, position == whole.
4670 So we need to increase `whole' to make space for the thumb. */
4677 top
= (float) position
/ whole
;
4678 shown
= (float) portion
/ whole
;
4681 if (NILP (bar
->dragging
))
4685 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4686 is the scroll bar's maximum and MIN is the scroll bar's minimum
4688 size
= shown
* XM_SB_MAX
;
4689 size
= min (size
, XM_SB_MAX
);
4690 size
= max (size
, 1);
4692 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4693 value
= top
* XM_SB_MAX
;
4694 value
= min (value
, XM_SB_MAX
- size
);
4696 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4698 #else /* !USE_MOTIF i.e. use Xaw */
4704 top
= (float) position
/ whole
;
4705 shown
= (float) portion
/ whole
;
4709 float old_top
, old_shown
;
4711 XtVaGetValues (widget
,
4712 XtNtopOfThumb
, &old_top
,
4713 XtNshown
, &old_shown
,
4717 /* Massage the top+shown values. */
4718 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4719 top
= max (0, min (1, top
));
4722 /* Keep two pixels available for moving the thumb down. */
4723 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4725 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4726 check that your system's configuration file contains a define
4727 for `NARROWPROTO'. See s/freebsd.h for an example. */
4728 if (top
!= old_top
|| shown
!= old_shown
)
4730 if (NILP (bar
->dragging
))
4731 XawScrollbarSetThumb (widget
, top
, shown
);
4735 ScrollbarWidget sb
= (ScrollbarWidget
) widget
;
4736 int scroll_mode
= 0;
4738 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
4739 if (xaw3d_arrow_scroll
)
4741 /* Xaw3d stupidly ignores resize requests while dragging
4742 so we have to make it believe it's not in dragging mode. */
4743 scroll_mode
= sb
->scrollbar
.scroll_mode
;
4744 if (scroll_mode
== 2)
4745 sb
->scrollbar
.scroll_mode
= 0;
4748 /* Try to make the scrolling a tad smoother. */
4749 if (!xaw3d_pick_top
)
4750 shown
= min (shown
, old_shown
);
4752 XawScrollbarSetThumb (widget
, top
, shown
);
4755 if (xaw3d_arrow_scroll
&& scroll_mode
== 2)
4756 sb
->scrollbar
.scroll_mode
= scroll_mode
;
4761 #endif /* !USE_MOTIF */
4765 #endif /* not USE_GTK */
4767 #endif /* USE_TOOLKIT_SCROLL_BARS */
4771 /************************************************************************
4772 Scroll bars, general
4773 ************************************************************************/
4775 /* Create a scroll bar and return the scroll bar vector for it. W is
4776 the Emacs window on which to create the scroll bar. TOP, LEFT,
4777 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4780 static struct scroll_bar
*
4781 x_scroll_bar_create (w
, top
, left
, width
, height
)
4783 int top
, left
, width
, height
;
4785 struct frame
*f
= XFRAME (w
->frame
);
4786 struct scroll_bar
*bar
4787 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
4791 #ifdef USE_TOOLKIT_SCROLL_BARS
4792 x_create_toolkit_scroll_bar (f
, bar
);
4793 #else /* not USE_TOOLKIT_SCROLL_BARS */
4795 XSetWindowAttributes a
;
4799 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4800 if (a
.background_pixel
== -1)
4801 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
4803 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4804 | ButtonMotionMask
| PointerMotionHintMask
4806 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4808 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4810 /* Clear the area of W that will serve as a scroll bar. This is
4811 for the case that a window has been split horizontally. In
4812 this case, no clear_frame is generated to reduce flickering. */
4813 if (width
> 0 && height
> 0)
4814 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4816 window_box_height (w
), False
);
4818 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4819 /* Position and size of scroll bar. */
4820 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4822 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4824 /* Border width, depth, class, and visual. */
4831 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
4833 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4835 XSETWINDOW (bar
->window
, w
);
4836 XSETINT (bar
->top
, top
);
4837 XSETINT (bar
->left
, left
);
4838 XSETINT (bar
->width
, width
);
4839 XSETINT (bar
->height
, height
);
4840 XSETINT (bar
->start
, 0);
4841 XSETINT (bar
->end
, 0);
4842 bar
->dragging
= Qnil
;
4844 /* Add bar to its frame's list of scroll bars. */
4845 bar
->next
= FRAME_SCROLL_BARS (f
);
4847 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4848 if (!NILP (bar
->next
))
4849 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4851 /* Map the window/widget. */
4852 #ifdef USE_TOOLKIT_SCROLL_BARS
4855 xg_update_scrollbar_pos (f
,
4856 SCROLL_BAR_X_WINDOW (bar
),
4858 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4859 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4861 xg_show_scroll_bar (SCROLL_BAR_X_WINDOW (bar
));
4862 #else /* not USE_GTK */
4863 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4864 XtConfigureWidget (scroll_bar
,
4865 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4867 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4868 max (height
, 1), 0);
4869 XtMapWidget (scroll_bar
);
4870 #endif /* not USE_GTK */
4872 #else /* not USE_TOOLKIT_SCROLL_BARS */
4873 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
4874 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4881 /* Draw BAR's handle in the proper position.
4883 If the handle is already drawn from START to END, don't bother
4884 redrawing it, unless REBUILD is non-zero; in that case, always
4885 redraw it. (REBUILD is handy for drawing the handle after expose
4888 Normally, we want to constrain the start and end of the handle to
4889 fit inside its rectangle, but if the user is dragging the scroll
4890 bar handle, we want to let them drag it down all the way, so that
4891 the bar's top is as far down as it goes; otherwise, there's no way
4892 to move to the very end of the buffer. */
4894 #ifndef USE_TOOLKIT_SCROLL_BARS
4897 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
4898 struct scroll_bar
*bar
;
4902 int dragging
= ! NILP (bar
->dragging
);
4903 Window w
= SCROLL_BAR_X_WINDOW (bar
);
4904 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4905 GC gc
= f
->output_data
.x
->normal_gc
;
4907 /* If the display is already accurate, do nothing. */
4909 && start
== XINT (bar
->start
)
4910 && end
== XINT (bar
->end
))
4916 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
4917 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
4918 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4920 /* Make sure the values are reasonable, and try to preserve
4921 the distance between start and end. */
4923 int length
= end
- start
;
4927 else if (start
> top_range
)
4929 end
= start
+ length
;
4933 else if (end
> top_range
&& ! dragging
)
4937 /* Store the adjusted setting in the scroll bar. */
4938 XSETINT (bar
->start
, start
);
4939 XSETINT (bar
->end
, end
);
4941 /* Clip the end position, just for display. */
4942 if (end
> top_range
)
4945 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4946 below top positions, to make sure the handle is always at least
4947 that many pixels tall. */
4948 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4950 /* Draw the empty space above the handle. Note that we can't clear
4951 zero-height areas; that means "clear to end of window." */
4953 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4954 /* x, y, width, height, and exposures. */
4955 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4956 VERTICAL_SCROLL_BAR_TOP_BORDER
,
4957 inside_width
, start
,
4960 /* Change to proper foreground color if one is specified. */
4961 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4962 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4963 f
->output_data
.x
->scroll_bar_foreground_pixel
);
4965 /* Draw the handle itself. */
4966 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
4967 /* x, y, width, height */
4968 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4969 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
4970 inside_width
, end
- start
);
4972 /* Restore the foreground color of the GC if we changed it above. */
4973 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4974 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4975 f
->output_data
.x
->foreground_pixel
);
4977 /* Draw the empty space below the handle. Note that we can't
4978 clear zero-height areas; that means "clear to end of window." */
4979 if (end
< inside_height
)
4980 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4981 /* x, y, width, height, and exposures. */
4982 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4983 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
4984 inside_width
, inside_height
- end
,
4992 #endif /* !USE_TOOLKIT_SCROLL_BARS */
4994 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4998 x_scroll_bar_remove (bar
)
4999 struct scroll_bar
*bar
;
5001 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5004 #ifdef USE_TOOLKIT_SCROLL_BARS
5006 xg_remove_scroll_bar (f
, SCROLL_BAR_X_WINDOW (bar
));
5007 #else /* not USE_GTK */
5008 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5009 #endif /* not USE_GTK */
5011 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
5014 /* Disassociate this scroll bar from its window. */
5015 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5021 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5022 that we are displaying PORTION characters out of a total of WHOLE
5023 characters, starting at POSITION. If WINDOW has no scroll bar,
5027 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
5029 int portion
, whole
, position
;
5031 struct frame
*f
= XFRAME (w
->frame
);
5032 struct scroll_bar
*bar
;
5033 int top
, height
, left
, sb_left
, width
, sb_width
;
5034 int window_y
, window_height
;
5036 /* Get window dimensions. */
5037 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5039 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5040 height
= window_height
;
5042 /* Compute the left edge of the scroll bar area. */
5043 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5045 /* Compute the width of the scroll bar which might be less than
5046 the width of the area reserved for the scroll bar. */
5047 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5048 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5052 /* Compute the left edge of the scroll bar. */
5053 #ifdef USE_TOOLKIT_SCROLL_BARS
5054 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5056 (WINDOW_RIGHTMOST_P (w
)
5057 ? width
- sb_width
- (width
- sb_width
) / 2
5061 (WINDOW_LEFTMOST_P (w
)
5062 ? (width
- sb_width
) / 2
5063 : width
- sb_width
));
5065 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5066 sb_left
= left
+ width
- sb_width
;
5071 /* Does the scroll bar exist yet? */
5072 if (NILP (w
->vertical_scroll_bar
))
5074 if (width
> 0 && height
> 0)
5077 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5078 left
, top
, width
, height
, False
);
5082 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5086 /* It may just need to be moved and resized. */
5087 unsigned int mask
= 0;
5089 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5093 if (sb_left
!= XINT (bar
->left
))
5095 if (top
!= XINT (bar
->top
))
5097 if (sb_width
!= XINT (bar
->width
))
5099 if (height
!= XINT (bar
->height
))
5102 #ifdef USE_TOOLKIT_SCROLL_BARS
5104 /* Move/size the scroll bar widget. */
5107 /* Since toolkit scroll bars are smaller than the space reserved
5108 for them on the frame, we have to clear "under" them. */
5109 if (width
> 0 && height
> 0)
5110 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5111 left
, top
, width
, height
, False
);
5113 xg_update_scrollbar_pos (f
,
5114 SCROLL_BAR_X_WINDOW (bar
),
5116 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5117 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5119 #else /* not USE_GTK */
5120 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5121 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5123 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5124 max (height
, 1), 0);
5125 #endif /* not USE_GTK */
5127 #else /* not USE_TOOLKIT_SCROLL_BARS */
5129 /* Clear areas not covered by the scroll bar because of
5130 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5131 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5133 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5134 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5136 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5137 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5138 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5142 /* Clear areas not covered by the scroll bar because it's not as
5143 wide as the area reserved for it. This makes sure a
5144 previous mode line display is cleared after C-x 2 C-x 1, for
5147 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5148 int rest
= area_width
- sb_width
;
5149 if (rest
> 0 && height
> 0)
5151 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5152 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5153 left
+ area_width
- rest
, top
,
5154 rest
, height
, False
);
5156 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5157 left
, top
, rest
, height
, False
);
5161 /* Move/size the scroll bar window. */
5166 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5168 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5170 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
5174 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5176 /* Remember new settings. */
5177 XSETINT (bar
->left
, sb_left
);
5178 XSETINT (bar
->top
, top
);
5179 XSETINT (bar
->width
, sb_width
);
5180 XSETINT (bar
->height
, height
);
5185 #ifdef USE_TOOLKIT_SCROLL_BARS
5186 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5187 #else /* not USE_TOOLKIT_SCROLL_BARS */
5188 /* Set the scroll bar's current state, unless we're currently being
5190 if (NILP (bar
->dragging
))
5192 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5195 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5198 int start
= ((double) position
* top_range
) / whole
;
5199 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5200 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5203 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5205 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5209 /* The following three hooks are used when we're doing a thorough
5210 redisplay of the frame. We don't explicitly know which scroll bars
5211 are going to be deleted, because keeping track of when windows go
5212 away is a real pain - "Can you say set-window-configuration, boys
5213 and girls?" Instead, we just assert at the beginning of redisplay
5214 that *all* scroll bars are to be removed, and then save a scroll bar
5215 from the fiery pit when we actually redisplay its window. */
5217 /* Arrange for all scroll bars on FRAME to be removed at the next call
5218 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5219 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5222 XTcondemn_scroll_bars (frame
)
5225 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5226 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5229 bar
= FRAME_SCROLL_BARS (frame
);
5230 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5231 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5232 XSCROLL_BAR (bar
)->prev
= Qnil
;
5233 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5234 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5235 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5240 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5241 Note that WINDOW isn't necessarily condemned at all. */
5244 XTredeem_scroll_bar (window
)
5245 struct window
*window
;
5247 struct scroll_bar
*bar
;
5250 /* We can't redeem this window's scroll bar if it doesn't have one. */
5251 if (NILP (window
->vertical_scroll_bar
))
5254 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5256 /* Unlink it from the condemned list. */
5257 f
= XFRAME (WINDOW_FRAME (window
));
5258 if (NILP (bar
->prev
))
5260 /* If the prev pointer is nil, it must be the first in one of
5262 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5263 /* It's not condemned. Everything's fine. */
5265 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5266 window
->vertical_scroll_bar
))
5267 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5269 /* If its prev pointer is nil, it must be at the front of
5270 one or the other! */
5274 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5276 if (! NILP (bar
->next
))
5277 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5279 bar
->next
= FRAME_SCROLL_BARS (f
);
5281 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5282 if (! NILP (bar
->next
))
5283 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5286 /* Remove all scroll bars on FRAME that haven't been saved since the
5287 last call to `*condemn_scroll_bars_hook'. */
5290 XTjudge_scroll_bars (f
)
5293 Lisp_Object bar
, next
;
5295 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5297 /* Clear out the condemned list now so we won't try to process any
5298 more events on the hapless scroll bars. */
5299 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5301 for (; ! NILP (bar
); bar
= next
)
5303 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5305 x_scroll_bar_remove (b
);
5308 b
->next
= b
->prev
= Qnil
;
5311 /* Now there should be no references to the condemned scroll bars,
5312 and they should get garbage-collected. */
5316 #ifndef USE_TOOLKIT_SCROLL_BARS
5317 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5318 is a no-op when using toolkit scroll bars.
5320 This may be called from a signal handler, so we have to ignore GC
5324 x_scroll_bar_expose (bar
, event
)
5325 struct scroll_bar
*bar
;
5328 Window w
= SCROLL_BAR_X_WINDOW (bar
);
5329 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5330 GC gc
= f
->output_data
.x
->normal_gc
;
5331 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5335 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
5337 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5338 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5340 /* x, y, width, height */
5342 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
5343 XINT (bar
->height
) - 1);
5348 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5350 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5351 is set to something other than NO_EVENT, it is enqueued.
5353 This may be called from a signal handler, so we have to ignore GC
5358 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
5359 struct scroll_bar
*bar
;
5361 struct input_event
*emacs_event
;
5363 if (! GC_WINDOWP (bar
->window
))
5366 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5367 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5368 emacs_event
->modifiers
5369 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5370 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5371 event
->xbutton
.state
)
5372 | (event
->type
== ButtonRelease
5375 emacs_event
->frame_or_window
= bar
->window
;
5376 emacs_event
->arg
= Qnil
;
5377 emacs_event
->timestamp
= event
->xbutton
.time
;
5380 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5382 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
5385 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5386 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5389 if (y
> top_range
) y
= top_range
;
5391 if (y
< XINT (bar
->start
))
5392 emacs_event
->part
= scroll_bar_above_handle
;
5393 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5394 emacs_event
->part
= scroll_bar_handle
;
5396 emacs_event
->part
= scroll_bar_below_handle
;
5398 /* Just because the user has clicked on the handle doesn't mean
5399 they want to drag it. Lisp code needs to be able to decide
5400 whether or not we're dragging. */
5402 /* If the user has just clicked on the handle, record where they're
5404 if (event
->type
== ButtonPress
5405 && emacs_event
->part
== scroll_bar_handle
)
5406 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
5409 #ifndef USE_TOOLKIT_SCROLL_BARS
5410 /* If the user has released the handle, set it to its final position. */
5411 if (event
->type
== ButtonRelease
5412 && ! NILP (bar
->dragging
))
5414 int new_start
= y
- XINT (bar
->dragging
);
5415 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5417 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5418 bar
->dragging
= Qnil
;
5422 /* Same deal here as the other #if 0. */
5424 /* Clicks on the handle are always reported as occurring at the top of
5426 if (emacs_event
->part
== scroll_bar_handle
)
5427 emacs_event
->x
= bar
->start
;
5429 XSETINT (emacs_event
->x
, y
);
5431 XSETINT (emacs_event
->x
, y
);
5434 XSETINT (emacs_event
->y
, top_range
);
5438 #ifndef USE_TOOLKIT_SCROLL_BARS
5440 /* Handle some mouse motion while someone is dragging the scroll bar.
5442 This may be called from a signal handler, so we have to ignore GC
5446 x_scroll_bar_note_movement (bar
, event
)
5447 struct scroll_bar
*bar
;
5450 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5452 last_mouse_movement_time
= event
->xmotion
.time
;
5455 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5457 /* If we're dragging the bar, display it. */
5458 if (! GC_NILP (bar
->dragging
))
5460 /* Where should the handle be now? */
5461 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5463 if (new_start
!= XINT (bar
->start
))
5465 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5467 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5472 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5474 /* Return information to the user about the current position of the mouse
5475 on the scroll bar. */
5478 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
5480 Lisp_Object
*bar_window
;
5481 enum scroll_bar_part
*part
;
5483 unsigned long *time
;
5485 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5486 Window w
= SCROLL_BAR_X_WINDOW (bar
);
5487 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5489 Window dummy_window
;
5491 unsigned int dummy_mask
;
5495 /* Get the mouse's position relative to the scroll bar window, and
5497 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5499 /* Root, child, root x and root y. */
5500 &dummy_window
, &dummy_window
,
5501 &dummy_coord
, &dummy_coord
,
5503 /* Position relative to scroll bar. */
5506 /* Mouse buttons and modifier keys. */
5513 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
5516 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5518 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5520 if (! NILP (bar
->dragging
))
5521 win_y
-= XINT (bar
->dragging
);
5525 if (win_y
> top_range
)
5529 *bar_window
= bar
->window
;
5531 if (! NILP (bar
->dragging
))
5532 *part
= scroll_bar_handle
;
5533 else if (win_y
< XINT (bar
->start
))
5534 *part
= scroll_bar_above_handle
;
5535 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5536 *part
= scroll_bar_handle
;
5538 *part
= scroll_bar_below_handle
;
5540 XSETINT (*x
, win_y
);
5541 XSETINT (*y
, top_range
);
5544 last_mouse_scroll_bar
= Qnil
;
5547 *time
= last_mouse_movement_time
;
5553 /* The screen has been cleared so we may have changed foreground or
5554 background colors, and the scroll bars may need to be redrawn.
5555 Clear out the scroll bars, and ask for expose events, so we can
5559 x_scroll_bar_clear (f
)
5562 #ifndef USE_TOOLKIT_SCROLL_BARS
5565 /* We can have scroll bars even if this is 0,
5566 if we just turned off scroll bar mode.
5567 But in that case we should not clear them. */
5568 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5569 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5570 bar
= XSCROLL_BAR (bar
)->next
)
5571 XClearArea (FRAME_X_DISPLAY (f
),
5572 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
5574 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5578 /* Define a queue to save up SelectionRequest events for later handling. */
5580 struct selection_event_queue
5583 struct selection_event_queue
*next
;
5586 static struct selection_event_queue
*queue
;
5588 /* Nonzero means queue up certain events--don't process them yet. */
5590 static int x_queue_selection_requests
;
5592 /* Queue up an X event *EVENT, to be processed later. */
5595 x_queue_event (f
, event
)
5599 struct selection_event_queue
*queue_tmp
5600 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
5602 if (queue_tmp
!= NULL
)
5604 queue_tmp
->event
= *event
;
5605 queue_tmp
->next
= queue
;
5610 /* Take all the queued events and put them back
5611 so that they get processed afresh. */
5614 x_unqueue_events (display
)
5617 while (queue
!= NULL
)
5619 struct selection_event_queue
*queue_tmp
= queue
;
5620 XPutBackEvent (display
, &queue_tmp
->event
);
5621 queue
= queue_tmp
->next
;
5622 xfree ((char *)queue_tmp
);
5626 /* Start queuing SelectionRequest events. */
5629 x_start_queuing_selection_requests (display
)
5632 x_queue_selection_requests
++;
5635 /* Stop queuing SelectionRequest events. */
5638 x_stop_queuing_selection_requests (display
)
5641 x_queue_selection_requests
--;
5642 x_unqueue_events (display
);
5645 /* The main X event-reading loop - XTread_socket. */
5648 /* Time stamp of enter window event. This is only used by XTread_socket,
5649 but we have to put it out here, since static variables within functions
5650 sometimes don't work. */
5652 static Time enter_timestamp
;
5655 /* This holds the state XLookupString needs to implement dead keys
5656 and other tricks known as "compose processing". _X Window System_
5657 says that a portable program can't use this, but Stephen Gildea assures
5658 me that letting the compiler initialize it to zeros will work okay.
5660 This must be defined outside of XTread_socket, for the same reasons
5661 given for enter_timestamp, above. */
5663 static XComposeStatus compose_status
;
5665 /* Record the last 100 characters stored
5666 to help debug the loss-of-chars-during-GC problem. */
5668 static int temp_index
;
5669 static short temp_buffer
[100];
5671 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5672 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5674 temp_buffer[temp_index++] = (keysym)
5676 /* Set this to nonzero to fake an "X I/O error"
5677 on a particular display. */
5679 struct x_display_info
*XTread_socket_fake_io_error
;
5681 /* When we find no input here, we occasionally do a no-op command
5682 to verify that the X server is still running and we can still talk with it.
5683 We try all the open displays, one by one.
5684 This variable is used for cycling thru the displays. */
5686 static struct x_display_info
*next_noop_dpyinfo
;
5688 #define SET_SAVED_MENU_EVENT(size) \
5691 if (f->output_data.x->saved_menu_event == 0) \
5692 f->output_data.x->saved_menu_event \
5693 = (XEvent *) xmalloc (sizeof (XEvent)); \
5694 bcopy (&event, f->output_data.x->saved_menu_event, size); \
5695 inev.kind = MENU_BAR_ACTIVATE_EVENT; \
5696 XSETFRAME (inev.frame_or_window, f); \
5700 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
5701 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
5711 /* Filter events for the current X input method.
5712 DPYINFO is the display this event is for.
5713 EVENT is the X event to filter.
5715 Returns non-zero if the event was filtered, caller shall not process
5717 Returns zero if event is wasn't filtered. */
5721 x_filter_event (dpyinfo
, event
)
5722 struct x_display_info
*dpyinfo
;
5725 /* XFilterEvent returns non-zero if the input method has
5726 consumed the event. We pass the frame's X window to
5727 XFilterEvent because that's the one for which the IC
5730 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5731 event
->xclient
.window
);
5733 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5738 static int current_count
;
5739 static int current_finish
;
5740 static struct input_event
*current_hold_quit
;
5742 /* This is the filter function invoked by the GTK event loop.
5743 It is invoked before the XEvent is translated to a GdkEvent,
5744 so we have a chance to act on the event before GTK. */
5745 static GdkFilterReturn
5746 event_handler_gdk (gxev
, ev
, data
)
5751 XEvent
*xev
= (XEvent
*) gxev
;
5753 if (current_count
>= 0)
5755 struct x_display_info
*dpyinfo
;
5757 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5760 /* Filter events for the current X input method.
5761 GTK calls XFilterEvent but not for key press and release,
5762 so we do it here. */
5763 if (xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5764 if (dpyinfo
&& x_filter_event (dpyinfo
, xev
))
5765 return GDK_FILTER_REMOVE
;
5769 current_finish
= X_EVENT_NORMAL
;
5773 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5778 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5780 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5781 return GDK_FILTER_REMOVE
;
5783 return GDK_FILTER_CONTINUE
;
5785 #endif /* USE_GTK */
5788 /* Handles the XEvent EVENT on display DPYINFO.
5790 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5791 *FINISH is zero if caller should continue reading events.
5792 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5794 We return the number of characters stored into the buffer. */
5797 handle_one_xevent (dpyinfo
, eventp
, finish
, hold_quit
)
5798 struct x_display_info
*dpyinfo
;
5801 struct input_event
*hold_quit
;
5803 struct input_event inev
;
5808 struct coding_system coding
;
5809 XEvent event
= *eventp
;
5811 *finish
= X_EVENT_NORMAL
;
5814 inev
.kind
= NO_EVENT
;
5821 if (event
.xclient
.message_type
5822 == dpyinfo
->Xatom_wm_protocols
5823 && event
.xclient
.format
== 32)
5825 if (event
.xclient
.data
.l
[0]
5826 == dpyinfo
->Xatom_wm_take_focus
)
5828 /* Use x_any_window_to_frame because this
5829 could be the shell widget window
5830 if the frame has no title bar. */
5831 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5833 /* Not quite sure this is needed -pd */
5834 if (f
&& FRAME_XIC (f
))
5835 XSetICFocus (FRAME_XIC (f
));
5837 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5838 instructs the WM to set the input focus automatically for
5839 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5840 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5841 it has set the focus. So, XSetInputFocus below is not
5844 The call to XSetInputFocus below has also caused trouble. In
5845 cases where the XSetInputFocus done by the WM and the one
5846 below are temporally close (on a fast machine), the call
5847 below can generate additional FocusIn events which confuse
5850 /* Since we set WM_TAKE_FOCUS, we must call
5851 XSetInputFocus explicitly. But not if f is null,
5852 since that might be an event for a deleted frame. */
5855 Display
*d
= event
.xclient
.display
;
5856 /* Catch and ignore errors, in case window has been
5857 iconified by a window manager such as GWM. */
5858 int count
= x_catch_errors (d
);
5859 XSetInputFocus (d
, event
.xclient
.window
,
5860 /* The ICCCM says this is
5861 the only valid choice. */
5863 event
.xclient
.data
.l
[1]);
5864 /* This is needed to detect the error
5865 if there is an error. */
5867 x_uncatch_errors (d
, count
);
5869 /* Not certain about handling scroll bars here */
5874 if (event
.xclient
.data
.l
[0]
5875 == dpyinfo
->Xatom_wm_save_yourself
)
5877 /* Save state modify the WM_COMMAND property to
5878 something which can reinstate us. This notifies
5879 the session manager, who's looking for such a
5880 PropertyNotify. Can restart processing when
5881 a keyboard or mouse event arrives. */
5882 /* If we have a session manager, don't set this.
5883 KDE will then start two Emacsen, one for the
5884 session manager and one for this. */
5886 if (! x_session_have_connection ())
5889 f
= x_top_window_to_frame (dpyinfo
,
5890 event
.xclient
.window
);
5891 /* This is just so we only give real data once
5892 for a single Emacs process. */
5893 if (f
== SELECTED_FRAME ())
5894 XSetCommand (FRAME_X_DISPLAY (f
),
5895 event
.xclient
.window
,
5896 initial_argv
, initial_argc
);
5898 XSetCommand (FRAME_X_DISPLAY (f
),
5899 event
.xclient
.window
,
5905 if (event
.xclient
.data
.l
[0]
5906 == dpyinfo
->Xatom_wm_delete_window
)
5908 f
= x_any_window_to_frame (dpyinfo
,
5909 event
.xclient
.window
);
5911 goto OTHER
; /* May be a dialog that is to be removed */
5913 inev
.kind
= DELETE_WINDOW_EVENT
;
5914 XSETFRAME (inev
.frame_or_window
, f
);
5921 if (event
.xclient
.message_type
5922 == dpyinfo
->Xatom_wm_configure_denied
)
5927 if (event
.xclient
.message_type
5928 == dpyinfo
->Xatom_wm_window_moved
)
5931 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5933 new_x
= event
.xclient
.data
.s
[0];
5934 new_y
= event
.xclient
.data
.s
[1];
5938 f
->left_pos
= new_x
;
5945 if (event
.xclient
.message_type
5946 == dpyinfo
->Xatom_editres
)
5948 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5949 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5953 #endif /* HACK_EDITRES */
5955 if ((event
.xclient
.message_type
5956 == dpyinfo
->Xatom_DONE
)
5957 || (event
.xclient
.message_type
5958 == dpyinfo
->Xatom_PAGE
))
5960 /* Ghostview job completed. Kill it. We could
5961 reply with "Next" if we received "Page", but we
5962 currently never do because we are interested in
5963 images, only, which should have 1 page. */
5964 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5965 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5966 x_kill_gs_process (pixmap
, f
);
5967 expose_frame (f
, 0, 0, 0, 0);
5971 #ifdef USE_TOOLKIT_SCROLL_BARS
5972 /* Scroll bar callbacks send a ClientMessage from which
5973 we construct an input_event. */
5974 if (event
.xclient
.message_type
5975 == dpyinfo
->Xatom_Scrollbar
)
5977 x_scroll_bar_to_input_event (&event
, &inev
);
5978 *finish
= X_EVENT_GOTO_OUT
;
5981 #endif /* USE_TOOLKIT_SCROLL_BARS */
5983 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5988 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
))
5989 *finish
= X_EVENT_DROP
;
5993 case SelectionNotify
:
5994 #ifdef USE_X_TOOLKIT
5995 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
5997 #endif /* not USE_X_TOOLKIT */
5998 x_handle_selection_notify (&event
.xselection
);
6001 case SelectionClear
: /* Someone has grabbed ownership. */
6002 #ifdef USE_X_TOOLKIT
6003 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
6005 #endif /* USE_X_TOOLKIT */
6007 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
6009 inev
.kind
= SELECTION_CLEAR_EVENT
;
6010 SELECTION_EVENT_DISPLAY (&inev
) = eventp
->display
;
6011 SELECTION_EVENT_SELECTION (&inev
) = eventp
->selection
;
6012 SELECTION_EVENT_TIME (&inev
) = eventp
->time
;
6013 inev
.frame_or_window
= Qnil
;
6017 case SelectionRequest
: /* Someone wants our selection. */
6018 #ifdef USE_X_TOOLKIT
6019 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
6021 #endif /* USE_X_TOOLKIT */
6022 if (x_queue_selection_requests
)
6023 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
6027 XSelectionRequestEvent
*eventp
6028 = (XSelectionRequestEvent
*) &event
;
6030 inev
.kind
= SELECTION_REQUEST_EVENT
;
6031 SELECTION_EVENT_DISPLAY (&inev
) = eventp
->display
;
6032 SELECTION_EVENT_REQUESTOR (&inev
) = eventp
->requestor
;
6033 SELECTION_EVENT_SELECTION (&inev
) = eventp
->selection
;
6034 SELECTION_EVENT_TARGET (&inev
) = eventp
->target
;
6035 SELECTION_EVENT_PROPERTY (&inev
) = eventp
->property
;
6036 SELECTION_EVENT_TIME (&inev
) = eventp
->time
;
6037 inev
.frame_or_window
= Qnil
;
6041 case PropertyNotify
:
6042 #if 0 /* This is plain wrong. In the case that we are waiting for a
6043 PropertyNotify used as an ACK in incremental selection
6044 transfer, the property will be on the receiver's window. */
6045 #if defined USE_X_TOOLKIT
6046 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
6050 x_handle_property_notify (&event
.xproperty
);
6053 case ReparentNotify
:
6054 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
6058 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
6059 x_real_positions (f
, &x
, &y
);
6063 /* Perhaps reparented due to a WM restart. Reset this. */
6064 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
6069 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
6072 x_check_fullscreen (f
);
6074 if (f
->async_visible
== 0)
6076 f
->async_visible
= 1;
6077 f
->async_iconified
= 0;
6078 f
->output_data
.x
->has_been_visible
= 1;
6079 SET_FRAME_GARBAGED (f
);
6083 event
.xexpose
.x
, event
.xexpose
.y
,
6084 event
.xexpose
.width
, event
.xexpose
.height
);
6088 #ifndef USE_TOOLKIT_SCROLL_BARS
6089 struct scroll_bar
*bar
;
6091 #if defined USE_LUCID
6092 /* Submenus of the Lucid menu bar aren't widgets
6093 themselves, so there's no way to dispatch events
6094 to them. Recognize this case separately. */
6097 = x_window_to_menu_bar (event
.xexpose
.window
);
6099 xlwmenu_redisplay (widget
);
6101 #endif /* USE_LUCID */
6103 #ifdef USE_TOOLKIT_SCROLL_BARS
6104 /* Dispatch event to the widget. */
6106 #else /* not USE_TOOLKIT_SCROLL_BARS */
6107 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
6108 event
.xexpose
.window
);
6111 x_scroll_bar_expose (bar
, &event
);
6112 #ifdef USE_X_TOOLKIT
6115 #endif /* USE_X_TOOLKIT */
6116 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6120 case GraphicsExpose
: /* This occurs when an XCopyArea's
6121 source area was obscured or not
6123 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6127 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6128 event
.xgraphicsexpose
.width
,
6129 event
.xgraphicsexpose
.height
);
6131 #ifdef USE_X_TOOLKIT
6134 #endif /* USE_X_TOOLKIT */
6137 case NoExpose
: /* This occurs when an XCopyArea's
6138 source area was completely
6143 /* Redo the mouse-highlight after the tooltip has gone. */
6144 if (event
.xmap
.window
== tip_window
)
6147 redo_mouse_highlight ();
6150 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6151 if (f
) /* F may no longer exist if
6152 the frame was deleted. */
6154 /* While a frame is unmapped, display generation is
6155 disabled; you don't want to spend time updating a
6156 display that won't ever be seen. */
6157 f
->async_visible
= 0;
6158 /* We can't distinguish, from the event, whether the window
6159 has become iconified or invisible. So assume, if it
6160 was previously visible, than now it is iconified.
6161 But x_make_frame_invisible clears both
6162 the visible flag and the iconified flag;
6163 and that way, we know the window is not iconified now. */
6164 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6166 f
->async_iconified
= 1;
6168 inev
.kind
= ICONIFY_EVENT
;
6169 XSETFRAME (inev
.frame_or_window
, f
);
6175 if (event
.xmap
.window
== tip_window
)
6176 /* The tooltip has been drawn already. Avoid
6177 the SET_FRAME_GARBAGED below. */
6180 /* We use x_top_window_to_frame because map events can
6181 come for sub-windows and they don't mean that the
6182 frame is visible. */
6183 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6186 /* wait_reading_process_output will notice this and update
6187 the frame's display structures.
6188 If we where iconified, we should not set garbaged,
6189 because that stops redrawing on Expose events. This looks
6190 bad if we are called from a recursive event loop
6191 (x_dispatch_event), for example when a dialog is up. */
6192 if (! f
->async_iconified
)
6193 SET_FRAME_GARBAGED (f
);
6195 f
->async_visible
= 1;
6196 f
->async_iconified
= 0;
6197 f
->output_data
.x
->has_been_visible
= 1;
6201 inev
.kind
= DEICONIFY_EVENT
;
6202 XSETFRAME (inev
.frame_or_window
, f
);
6204 else if (! NILP (Vframe_list
)
6205 && ! NILP (XCDR (Vframe_list
)))
6206 /* Force a redisplay sooner or later
6207 to update the frame titles
6208 in case this is the second frame. */
6209 record_asynch_buffer_change ();
6215 ignore_next_mouse_click_timeout
= 0;
6217 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6218 /* Dispatch KeyPress events when in menu. */
6219 if (popup_activated ())
6223 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6225 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
6227 clear_mouse_face (dpyinfo
);
6228 dpyinfo
->mouse_face_hidden
= 1;
6231 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6234 /* Scroll bars consume key events, but we want
6235 the keys to go to the scroll bar's frame. */
6236 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6238 if (widget
&& XmIsScrollBar (widget
))
6240 widget
= XtParent (widget
);
6241 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6244 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6248 KeySym keysym
, orig_keysym
;
6249 /* al%imercury@uunet.uu.net says that making this 81
6250 instead of 80 fixed a bug whereby meta chars made
6253 It seems that some version of XmbLookupString has
6254 a bug of not returning XBufferOverflow in
6255 status_return even if the input is too long to
6256 fit in 81 bytes. So, we must prepare sufficient
6257 bytes for copy_buffer. 513 bytes (256 chars for
6258 two-byte character set) seems to be a fairly good
6259 approximation. -- 2000.8.10 handa@etl.go.jp */
6260 unsigned char copy_buffer
[513];
6261 unsigned char *copy_bufptr
= copy_buffer
;
6262 int copy_bufsiz
= sizeof (copy_buffer
);
6264 Lisp_Object coding_system
= Qlatin_1
;
6268 /* Don't pass keys to GTK. A Tab will shift focus to the
6269 tool bar in GTK 2.4. Keys will still go to menus and
6270 dialogs because in that case popup_activated is TRUE
6272 *finish
= X_EVENT_DROP
;
6276 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6277 extra_keyboard_modifiers
);
6278 modifiers
= event
.xkey
.state
;
6280 /* This will have to go some day... */
6282 /* make_lispy_event turns chars into control chars.
6283 Don't do it here because XLookupString is too eager. */
6284 event
.xkey
.state
&= ~ControlMask
;
6285 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6286 | dpyinfo
->super_mod_mask
6287 | dpyinfo
->hyper_mod_mask
6288 | dpyinfo
->alt_mod_mask
);
6290 /* In case Meta is ComposeCharacter,
6291 clear its status. According to Markus Ehrnsperger
6292 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6293 this enables ComposeCharacter to work whether or
6294 not it is combined with Meta. */
6295 if (modifiers
& dpyinfo
->meta_mod_mask
)
6296 bzero (&compose_status
, sizeof (compose_status
));
6301 Status status_return
;
6303 coding_system
= Vlocale_coding_system
;
6304 nbytes
= XmbLookupString (FRAME_XIC (f
),
6305 &event
.xkey
, copy_bufptr
,
6306 copy_bufsiz
, &keysym
,
6308 if (status_return
== XBufferOverflow
)
6310 copy_bufsiz
= nbytes
+ 1;
6311 copy_bufptr
= (char *) alloca (copy_bufsiz
);
6312 nbytes
= XmbLookupString (FRAME_XIC (f
),
6313 &event
.xkey
, copy_bufptr
,
6314 copy_bufsiz
, &keysym
,
6317 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6318 #if 0 && defined X_HAVE_UTF8_STRING
6319 else if (status_return
== XLookupKeySym
)
6320 { /* Try again but with utf-8. */
6321 coding_system
= Qutf_8
;
6322 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6323 &event
.xkey
, copy_bufptr
,
6324 copy_bufsiz
, &keysym
,
6326 if (status_return
== XBufferOverflow
)
6328 copy_bufsiz
= nbytes
+ 1;
6329 copy_bufptr
= (char *) alloca (copy_bufsiz
);
6330 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6333 copy_bufsiz
, &keysym
,
6339 if (status_return
== XLookupNone
)
6341 else if (status_return
== XLookupChars
)
6346 else if (status_return
!= XLookupKeySym
6347 && status_return
!= XLookupBoth
)
6351 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6352 copy_bufsiz
, &keysym
,
6355 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6356 copy_bufsiz
, &keysym
,
6360 /* If not using XIM/XIC, and a compose sequence is in progress,
6361 we break here. Otherwise, chars_matched is always 0. */
6362 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6365 orig_keysym
= keysym
;
6367 /* Common for all keysym input events. */
6368 XSETFRAME (inev
.frame_or_window
, f
);
6370 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6371 inev
.timestamp
= event
.xkey
.time
;
6373 /* First deal with keysyms which have defined
6374 translations to characters. */
6375 if (keysym
>= 32 && keysym
< 128)
6376 /* Avoid explicitly decoding each ASCII character. */
6378 inev
.kind
= ASCII_KEYSTROKE_EVENT
;
6383 /* Now non-ASCII. */
6384 if (HASH_TABLE_P (Vx_keysym_table
)
6385 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6389 inev
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6390 ? ASCII_KEYSTROKE_EVENT
6391 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6392 inev
.code
= XFASTINT (c
);
6396 /* Random non-modifier sorts of keysyms. */
6397 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6398 || keysym
== XK_Delete
6399 #ifdef XK_ISO_Left_Tab
6400 || (keysym
>= XK_ISO_Left_Tab
6401 && keysym
<= XK_ISO_Enter
)
6403 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6404 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6406 /* This recognizes the "extended function
6407 keys". It seems there's no cleaner way.
6408 Test IsModifierKey to avoid handling
6409 mode_switch incorrectly. */
6410 || ((unsigned) (keysym
) >= XK_Select
6411 && (unsigned)(keysym
) < XK_KP_Space
)
6413 #ifdef XK_dead_circumflex
6414 || orig_keysym
== XK_dead_circumflex
6416 #ifdef XK_dead_grave
6417 || orig_keysym
== XK_dead_grave
6419 #ifdef XK_dead_tilde
6420 || orig_keysym
== XK_dead_tilde
6422 #ifdef XK_dead_diaeresis
6423 || orig_keysym
== XK_dead_diaeresis
6425 #ifdef XK_dead_macron
6426 || orig_keysym
== XK_dead_macron
6428 #ifdef XK_dead_degree
6429 || orig_keysym
== XK_dead_degree
6431 #ifdef XK_dead_acute
6432 || orig_keysym
== XK_dead_acute
6434 #ifdef XK_dead_cedilla
6435 || orig_keysym
== XK_dead_cedilla
6437 #ifdef XK_dead_breve
6438 || orig_keysym
== XK_dead_breve
6440 #ifdef XK_dead_ogonek
6441 || orig_keysym
== XK_dead_ogonek
6443 #ifdef XK_dead_caron
6444 || orig_keysym
== XK_dead_caron
6446 #ifdef XK_dead_doubleacute
6447 || orig_keysym
== XK_dead_doubleacute
6449 #ifdef XK_dead_abovedot
6450 || orig_keysym
== XK_dead_abovedot
6452 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6453 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6454 /* Any "vendor-specific" key is ok. */
6455 || (orig_keysym
& (1 << 28))
6456 || (keysym
!= NoSymbol
&& nbytes
== 0))
6457 && ! (IsModifierKey (orig_keysym
)
6459 #ifdef XK_Mode_switch
6460 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
6463 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
6465 #endif /* not HAVE_X11R5 */
6466 /* The symbols from XK_ISO_Lock
6467 to XK_ISO_Last_Group_Lock
6468 don't have real modifiers but
6469 should be treated similarly to
6470 Mode_switch by Emacs. */
6471 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6472 || ((unsigned)(orig_keysym
)
6474 && (unsigned)(orig_keysym
)
6475 <= XK_ISO_Last_Group_Lock
)
6479 STORE_KEYSYM_FOR_DEBUG (keysym
);
6480 /* make_lispy_event will convert this to a symbolic
6482 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6487 { /* Raw bytes, not keysym. */
6492 /* The input should be decoded with `coding_system'
6493 which depends on which X*LookupString function
6494 we used just above and the locale. */
6495 setup_coding_system (coding_system
, &coding
);
6496 coding
.src_multibyte
= 0;
6497 coding
.dst_multibyte
= 1;
6498 /* The input is converted to events, thus we can't
6499 handle composition. Anyway, there's no XIM that
6500 gives us composition information. */
6501 coding
.composing
= COMPOSITION_DISABLED
;
6503 for (i
= 0; i
< nbytes
; i
++)
6505 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6509 /* Decode the input data. */
6513 require
= decoding_buffer_size (&coding
, nbytes
);
6514 p
= (unsigned char *) alloca (require
);
6515 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6516 /* We explicitly disable composition handling because
6517 key data should not contain any composition sequence. */
6518 coding
.composing
= COMPOSITION_DISABLED
;
6519 decode_coding (&coding
, copy_bufptr
, p
, nbytes
, require
);
6520 nbytes
= coding
.produced
;
6521 nchars
= coding
.produced_char
;
6525 /* Convert the input data to a sequence of
6526 character events. */
6527 for (i
= 0; i
< nbytes
; i
+= len
)
6529 if (nchars
== nbytes
)
6530 c
= copy_bufptr
[i
], len
= 1;
6532 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
6534 inev
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6535 ? ASCII_KEYSTROKE_EVENT
6536 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6538 kbd_buffer_store_event_hold (&inev
, hold_quit
);
6541 /* Previous code updated count by nchars rather than nbytes,
6542 but that seems bogus to me. ++kfs */
6545 inev
.kind
= NO_EVENT
; /* Already stored above. */
6547 if (keysym
== NoSymbol
)
6553 /* Don't dispatch this event since XtDispatchEvent calls
6554 XFilterEvent, and two calls in a row may freeze the
6563 /* Don't dispatch this event since XtDispatchEvent calls
6564 XFilterEvent, and two calls in a row may freeze the
6572 x_detect_focus_change (dpyinfo
, &event
, &inev
);
6574 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6576 if (f
&& x_mouse_click_focus_ignore_position
)
6577 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6580 if (event
.xcrossing
.focus
)
6582 /* Avoid nasty pop/raise loops. */
6583 if (f
&& (!(f
->auto_raise
)
6585 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
6587 x_new_focus_frame (dpyinfo
, f
);
6588 enter_timestamp
= event
.xcrossing
.time
;
6591 else if (f
== dpyinfo
->x_focus_frame
)
6592 x_new_focus_frame (dpyinfo
, 0);
6595 /* EnterNotify counts as mouse movement,
6596 so update things that depend on mouse position. */
6597 if (f
&& !f
->output_data
.x
->hourglass_p
)
6598 note_mouse_movement (f
, &event
.xmotion
);
6602 x_detect_focus_change (dpyinfo
, &event
, &inev
);
6606 x_detect_focus_change (dpyinfo
, &event
, &inev
);
6608 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6611 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6613 /* If we move outside the frame, then we're
6614 certainly no longer on any text in the frame. */
6615 clear_mouse_face (dpyinfo
);
6616 dpyinfo
->mouse_face_mouse_frame
= 0;
6619 /* Generate a nil HELP_EVENT to cancel a help-echo.
6620 Do it only if there's something to cancel.
6621 Otherwise, the startup message is cleared when
6622 the mouse leaves the frame. */
6623 if (any_help_event_p
)
6629 x_detect_focus_change (dpyinfo
, &event
, &inev
);
6634 previous_help_echo_string
= help_echo_string
;
6635 help_echo_string
= help_echo_object
= help_echo_window
= Qnil
;
6638 if (dpyinfo
->grabbed
&& last_mouse_frame
6639 && FRAME_LIVE_P (last_mouse_frame
))
6640 f
= last_mouse_frame
;
6642 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6644 if (dpyinfo
->mouse_face_hidden
)
6646 dpyinfo
->mouse_face_hidden
= 0;
6647 clear_mouse_face (dpyinfo
);
6653 /* Generate SELECT_WINDOW_EVENTs when needed. */
6654 if (mouse_autoselect_window
)
6658 window
= window_from_coordinates (f
,
6659 event
.xmotion
.x
, event
.xmotion
.y
,
6662 /* Window will be selected only when it is not selected now and
6663 last mouse movement event was not in it. Minibuffer window
6664 will be selected iff it is active. */
6665 if (WINDOWP (window
)
6666 && !EQ (window
, last_window
)
6667 && !EQ (window
, selected_window
))
6669 inev
.kind
= SELECT_WINDOW_EVENT
;
6670 inev
.frame_or_window
= window
;
6675 note_mouse_movement (f
, &event
.xmotion
);
6679 #ifndef USE_TOOLKIT_SCROLL_BARS
6680 struct scroll_bar
*bar
6681 = x_window_to_scroll_bar (event
.xmotion
.display
,
6682 event
.xmotion
.window
);
6685 x_scroll_bar_note_movement (bar
, &event
);
6686 #endif /* USE_TOOLKIT_SCROLL_BARS */
6688 /* If we move outside the frame, then we're
6689 certainly no longer on any text in the frame. */
6690 clear_mouse_face (dpyinfo
);
6693 /* If the contents of the global variable help_echo_string
6694 has changed, generate a HELP_EVENT. */
6695 if (!NILP (help_echo_string
)
6696 || !NILP (previous_help_echo_string
))
6701 case ConfigureNotify
:
6702 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6705 #ifndef USE_X_TOOLKIT
6707 xg_resize_widgets (f
, event
.xconfigure
.width
,
6708 event
.xconfigure
.height
);
6709 #else /* not USE_GTK */
6710 /* If there is a pending resize for fullscreen, don't
6711 do this one, the right one will come later.
6712 The toolkit version doesn't seem to need this, but we
6713 need to reset it below. */
6715 = ((f
->want_fullscreen
& FULLSCREEN_WAIT
)
6716 && f
->new_text_cols
!= 0);
6717 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6718 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6723 /* In the toolkit version, change_frame_size
6724 is called by the code that handles resizing
6725 of the EmacsFrame widget. */
6727 /* Even if the number of character rows and columns has
6728 not changed, the font size may have changed, so we need
6729 to check the pixel dimensions as well. */
6730 if (columns
!= FRAME_COLS (f
)
6731 || rows
!= FRAME_LINES (f
)
6732 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6733 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6735 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6736 SET_FRAME_GARBAGED (f
);
6737 cancel_mouse_face (f
);
6739 #endif /* not USE_GTK */
6742 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6743 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6746 /* GTK creates windows but doesn't map them.
6747 Only get real positions and check fullscreen when mapped. */
6748 if (FRAME_GTK_OUTER_WIDGET (f
)
6749 && GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
6752 /* What we have now is the position of Emacs's own window.
6753 Convert that to the position of the window manager window. */
6754 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6756 x_check_expected_move (f
);
6757 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
6758 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
6762 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6763 xic_set_statusarea (f
);
6766 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
6768 /* Since the WM decorations come below top_pos now,
6769 we must put them below top_pos in the future. */
6770 f
->win_gravity
= NorthWestGravity
;
6771 x_wm_set_size_hint (f
, (long) 0, 0);
6779 /* If we decide we want to generate an event to be seen
6780 by the rest of Emacs, we put it here. */
6783 bzero (&compose_status
, sizeof (compose_status
));
6785 if (dpyinfo
->grabbed
6787 && FRAME_LIVE_P (last_mouse_frame
))
6788 f
= last_mouse_frame
;
6790 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6794 /* Is this in the tool-bar? */
6795 if (WINDOWP (f
->tool_bar_window
)
6796 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6799 int x
= event
.xbutton
.x
;
6800 int y
= event
.xbutton
.y
;
6802 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
6803 if (EQ (window
, f
->tool_bar_window
))
6805 if (event
.xbutton
.type
== ButtonPress
)
6806 handle_tool_bar_click (f
, x
, y
, 1, 0);
6808 handle_tool_bar_click (f
, x
, y
, 0,
6809 x_x_to_emacs_modifiers (dpyinfo
,
6810 event
.xbutton
.state
));
6816 if (!dpyinfo
->x_focus_frame
6817 || f
== dpyinfo
->x_focus_frame
)
6819 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6820 if (! popup_activated ())
6823 if (ignore_next_mouse_click_timeout
)
6825 if (event
.type
== ButtonPress
6826 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6828 ignore_next_mouse_click_timeout
= 0;
6829 construct_mouse_click (&inev
, &event
, f
);
6831 if (event
.type
== ButtonRelease
)
6832 ignore_next_mouse_click_timeout
= 0;
6835 construct_mouse_click (&inev
, &event
, f
);
6841 struct scroll_bar
*bar
6842 = x_window_to_scroll_bar (event
.xbutton
.display
,
6843 event
.xbutton
.window
);
6845 #ifdef USE_TOOLKIT_SCROLL_BARS
6846 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6848 if (bar
&& event
.xbutton
.state
& ControlMask
)
6850 x_scroll_bar_handle_click (bar
, &event
, &inev
);
6851 *finish
= X_EVENT_DROP
;
6853 #else /* not USE_TOOLKIT_SCROLL_BARS */
6855 x_scroll_bar_handle_click (bar
, &event
, &inev
);
6856 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6859 if (event
.type
== ButtonPress
)
6861 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6862 last_mouse_frame
= f
;
6863 /* Ignore any mouse motion that happened
6864 before this event; any subsequent mouse-movement
6865 Emacs events should reflect only motion after
6871 last_tool_bar_item
= -1;
6874 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6876 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6877 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6878 /* For a down-event in the menu bar,
6879 don't pass it to Xt right now.
6880 Instead, save it away
6881 and we will pass it to Xt from kbd_buffer_get_event.
6882 That way, we can run some Lisp code first. */
6885 ! popup_activated ()
6888 f
&& event
.type
== ButtonPress
6889 /* Verify the event is really within the menu bar
6890 and not just sent to it due to grabbing. */
6891 && event
.xbutton
.x
>= 0
6892 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6893 && event
.xbutton
.y
>= 0
6894 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6895 && event
.xbutton
.same_screen
)
6897 SET_SAVED_BUTTON_EVENT
;
6898 XSETFRAME (last_mouse_press_frame
, f
);
6900 *finish
= X_EVENT_DROP
;
6903 else if (event
.type
== ButtonPress
)
6905 last_mouse_press_frame
= Qnil
;
6909 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6910 but I am trying to be cautious. */
6911 else if (event
.type
== ButtonRelease
)
6913 if (!NILP (last_mouse_press_frame
))
6915 f
= XFRAME (last_mouse_press_frame
);
6916 if (f
->output_data
.x
)
6917 SET_SAVED_BUTTON_EVENT
;
6922 #endif /* USE_MOTIF */
6925 #endif /* USE_X_TOOLKIT || USE_GTK */
6929 case CirculateNotify
:
6932 case CirculateRequest
:
6935 case VisibilityNotify
:
6939 /* Someone has changed the keyboard mapping - update the
6941 switch (event
.xmapping
.request
)
6943 case MappingModifier
:
6944 x_find_modifier_meanings (dpyinfo
);
6945 /* This is meant to fall through. */
6946 case MappingKeyboard
:
6947 XRefreshKeyboardMapping (&event
.xmapping
);
6953 #ifdef USE_X_TOOLKIT
6955 if (*finish
!= X_EVENT_DROP
)
6956 XtDispatchEvent (&event
);
6958 #endif /* USE_X_TOOLKIT */
6963 if (inev
.kind
!= NO_EVENT
)
6965 kbd_buffer_store_event_hold (&inev
, hold_quit
);
6970 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6975 XSETFRAME (frame
, f
);
6981 any_help_event_p
= 1;
6982 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6983 help_echo_object
, help_echo_pos
);
6987 help_echo_string
= Qnil
;
6988 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6998 /* Handles the XEvent EVENT on display DISPLAY.
6999 This is used for event loops outside the normal event handling,
7000 i.e. looping while a popup menu or a dialog is posted.
7002 Returns the value handle_one_xevent sets in the finish argument. */
7004 x_dispatch_event (event
, display
)
7008 struct x_display_info
*dpyinfo
;
7009 int finish
= X_EVENT_NORMAL
;
7011 dpyinfo
= x_display_info_for_display (display
);
7014 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
7020 /* Read events coming from the X server.
7021 This routine is called by the SIGIO handler.
7022 We return as soon as there are no more events to be read.
7024 We return the number of characters stored into the buffer,
7025 thus pretending to be `read'.
7027 EXPECTED is nonzero if the caller knows input is available. */
7030 XTread_socket (sd
, expected
, hold_quit
)
7033 struct input_event
*hold_quit
;
7037 int event_found
= 0;
7038 struct x_display_info
*dpyinfo
;
7040 if (interrupt_input_blocked
)
7042 interrupt_input_pending
= 1;
7046 interrupt_input_pending
= 0;
7049 /* So people can tell when we have read the available input. */
7050 input_signal_count
++;
7054 /* Find the display we are supposed to read input for.
7055 It's the one communicating on descriptor SD. */
7056 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
7058 #if 0 /* This ought to be unnecessary; let's verify it. */
7060 /* If available, Xlib uses FIOSNBIO to make the socket
7061 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
7062 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
7063 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
7064 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
7065 #endif /* ! defined (FIOSNBIO) */
7068 #if 0 /* This code can't be made to work, with multiple displays,
7069 and appears not to be used on any system any more.
7070 Also keyboard.c doesn't turn O_NDELAY on and off
7071 for X connections. */
7074 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
7076 extern int read_alarm_should_throw
;
7077 read_alarm_should_throw
= 1;
7078 XPeekEvent (dpyinfo
->display
, &event
);
7079 read_alarm_should_throw
= 0;
7081 #endif /* HAVE_SELECT */
7085 /* For debugging, this gives a way to fake an I/O error. */
7086 if (dpyinfo
== XTread_socket_fake_io_error
)
7088 XTread_socket_fake_io_error
= 0;
7089 x_io_error_quitter (dpyinfo
->display
);
7094 struct input_event inev
;
7096 /* We don't need to EVENT_INIT (inev) here, as
7097 x_session_check_input copies an entire input_event. */
7098 if (x_session_check_input (&inev
))
7100 kbd_buffer_store_event_hold (&inev
, hold_quit
);
7108 while (XPending (dpyinfo
->display
))
7112 XNextEvent (dpyinfo
->display
, &event
);
7115 /* Filter events for the current X input method. */
7116 if (x_filter_event (dpyinfo
, &event
))
7121 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
7123 if (finish
== X_EVENT_GOTO_OUT
)
7126 #endif /* not USE_GTK */
7131 /* For GTK we must use the GTK event loop. But XEvents gets passed
7132 to our filter function above, and then to the big event switch.
7133 We use a bunch of globals to communicate with our filter function,
7134 that is kind of ugly, but it works.
7136 There is no way to do one display at the time, GTK just does events
7137 from all displays. */
7139 while (gtk_events_pending ())
7141 current_count
= count
;
7142 current_hold_quit
= hold_quit
;
7144 gtk_main_iteration ();
7146 count
= current_count
;
7148 current_hold_quit
= 0;
7150 if (current_finish
== X_EVENT_GOTO_OUT
)
7153 #endif /* USE_GTK */
7157 /* On some systems, an X bug causes Emacs to get no more events
7158 when the window is destroyed. Detect that. (1994.) */
7161 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7162 One XNOOP in 100 loops will make Emacs terminate.
7163 B. Bretthauer, 1994 */
7165 if (x_noop_count
>= 100)
7169 if (next_noop_dpyinfo
== 0)
7170 next_noop_dpyinfo
= x_display_list
;
7172 XNoOp (next_noop_dpyinfo
->display
);
7174 /* Each time we get here, cycle through the displays now open. */
7175 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7179 /* If the focus was just given to an auto-raising frame,
7181 /* ??? This ought to be able to handle more than one such frame. */
7182 if (pending_autoraise_frame
)
7184 x_raise_frame (pending_autoraise_frame
);
7185 pending_autoraise_frame
= 0;
7197 /***********************************************************************
7199 ***********************************************************************/
7201 /* Set clipping for output in glyph row ROW. W is the window in which
7202 we operate. GC is the graphics context to set clipping in.
7204 ROW may be a text row or, e.g., a mode line. Text rows must be
7205 clipped to the interior of the window dedicated to text display,
7206 mode lines must be clipped to the whole window. */
7209 x_clip_to_row (w
, row
, gc
)
7211 struct glyph_row
*row
;
7214 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7215 XRectangle clip_rect
;
7216 int window_y
, window_width
;
7218 window_box (w
, -1, 0, &window_y
, &window_width
, 0);
7220 clip_rect
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
7221 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
7222 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7223 clip_rect
.width
= window_width
;
7224 clip_rect
.height
= row
->visible_height
;
7226 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7230 /* Draw a hollow box cursor on window W in glyph row ROW. */
7233 x_draw_hollow_cursor (w
, row
)
7235 struct glyph_row
*row
;
7237 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7238 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7239 Display
*dpy
= FRAME_X_DISPLAY (f
);
7242 struct glyph
*cursor_glyph
;
7245 /* Get the glyph the cursor is on. If we can't tell because
7246 the current matrix is invalid or such, give up. */
7247 cursor_glyph
= get_phys_cursor_glyph (w
);
7248 if (cursor_glyph
== NULL
)
7251 /* Compute the width of the rectangle to draw. If on a stretch
7252 glyph, and `x-stretch-block-cursor' is nil, don't draw a
7253 rectangle as wide as the glyph, but use a canonical character
7255 wd
= cursor_glyph
->pixel_width
- 1;
7256 if (cursor_glyph
->type
== STRETCH_GLYPH
7257 && !x_stretch_cursor_p
)
7258 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
7259 w
->phys_cursor_width
= wd
;
7261 /* Compute frame-relative coordinates from window-relative
7263 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7264 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
);
7266 /* Compute the proper height and ascent of the rectangle, based
7267 on the actual glyph. Using the full height of the row looks
7268 bad when there are tall images on that row. */
7269 h
= max (min (FRAME_LINE_HEIGHT (f
), row
->height
),
7270 cursor_glyph
->ascent
+ cursor_glyph
->descent
);
7271 if (h
< row
->height
)
7272 y
+= row
->ascent
/* - w->phys_cursor_ascent */ + cursor_glyph
->descent
- h
;
7275 /* The foreground of cursor_gc is typically the same as the normal
7276 background color, which can cause the cursor box to be invisible. */
7277 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7278 if (dpyinfo
->scratch_cursor_gc
)
7279 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7281 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7282 GCForeground
, &xgcv
);
7283 gc
= dpyinfo
->scratch_cursor_gc
;
7285 /* Set clipping, draw the rectangle, and reset clipping again. */
7286 x_clip_to_row (w
, row
, gc
);
7287 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
7288 XSetClipMask (dpy
, gc
, None
);
7292 /* Draw a bar cursor on window W in glyph row ROW.
7294 Implementation note: One would like to draw a bar cursor with an
7295 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7296 Unfortunately, I didn't find a font yet that has this property set.
7300 x_draw_bar_cursor (w
, row
, width
, kind
)
7302 struct glyph_row
*row
;
7304 enum text_cursor_kinds kind
;
7306 struct frame
*f
= XFRAME (w
->frame
);
7307 struct glyph
*cursor_glyph
;
7309 /* If cursor is out of bounds, don't draw garbage. This can happen
7310 in mini-buffer windows when switching between echo area glyphs
7312 cursor_glyph
= get_phys_cursor_glyph (w
);
7313 if (cursor_glyph
== NULL
)
7316 /* If on an image, draw like a normal cursor. That's usually better
7317 visible than drawing a bar, esp. if the image is large so that
7318 the bar might not be in the window. */
7319 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7321 struct glyph_row
*row
;
7322 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7323 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7327 Display
*dpy
= FRAME_X_DISPLAY (f
);
7328 Window window
= FRAME_X_WINDOW (f
);
7329 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7330 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7331 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7334 /* If the glyph's background equals the color we normally draw
7335 the bar cursor in, the bar cursor in its normal color is
7336 invisible. Use the glyph's foreground color instead in this
7337 case, on the assumption that the glyph's colors are chosen so
7338 that the glyph is legible. */
7339 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7340 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7342 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7343 xgcv
.graphics_exposures
= 0;
7346 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7349 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7350 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7354 width
= FRAME_CURSOR_WIDTH (f
);
7355 width
= min (cursor_glyph
->pixel_width
, width
);
7357 w
->phys_cursor_width
= width
;
7358 x_clip_to_row (w
, row
, gc
);
7360 if (kind
== BAR_CURSOR
)
7361 XFillRectangle (dpy
, window
, gc
,
7362 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7363 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7364 width
, row
->height
);
7366 XFillRectangle (dpy
, window
, gc
,
7367 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7368 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7369 row
->height
- width
),
7370 cursor_glyph
->pixel_width
,
7373 XSetClipMask (dpy
, gc
, None
);
7378 /* RIF: Define cursor CURSOR on frame F. */
7381 x_define_frame_cursor (f
, cursor
)
7385 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7389 /* RIF: Clear area on frame F. */
7392 x_clear_frame_area (f
, x
, y
, width
, height
)
7394 int x
, y
, width
, height
;
7396 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7397 x
, y
, width
, height
, False
);
7401 /* RIF: Draw cursor on window W. */
7404 x_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
7406 struct glyph_row
*glyph_row
;
7408 int cursor_type
, cursor_width
;
7411 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7415 w
->phys_cursor_type
= cursor_type
;
7416 w
->phys_cursor_on_p
= 1;
7418 if (glyph_row
->exact_window_width_line_p
7419 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
7421 glyph_row
->cursor_in_fringe_p
= 1;
7422 draw_fringe_bitmap (w
, glyph_row
, 0);
7425 switch (cursor_type
)
7427 case HOLLOW_BOX_CURSOR
:
7428 x_draw_hollow_cursor (w
, glyph_row
);
7431 case FILLED_BOX_CURSOR
:
7432 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7436 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7440 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7444 w
->phys_cursor_width
= 0;
7452 if (w
== XWINDOW (f
->selected_window
))
7453 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7454 xic_set_preeditarea (w
, x
, y
);
7459 if (updating_frame
!= f
)
7460 XFlush (FRAME_X_DISPLAY (f
));
7467 /* Make the x-window of frame F use the gnu icon bitmap. */
7470 x_bitmap_icon (f
, file
)
7476 if (FRAME_X_WINDOW (f
) == 0)
7479 /* Free up our existing icon bitmap and mask if any. */
7480 if (f
->output_data
.x
->icon_bitmap
> 0)
7481 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7482 f
->output_data
.x
->icon_bitmap
= 0;
7487 /* Use gtk_window_set_icon_from_file () if available,
7488 It's not restricted to bitmaps */
7489 if (xg_set_icon (f
, file
))
7491 #endif /* USE_GTK */
7492 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7493 x_create_bitmap_mask (f
, bitmap_id
);
7497 /* Create the GNU bitmap and mask if necessary. */
7498 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7500 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
7501 = x_create_bitmap_from_data (f
, gnu_bits
,
7502 gnu_width
, gnu_height
);
7503 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7506 /* The first time we create the GNU bitmap and mask,
7507 this increments the ref-count one extra time.
7508 As a result, the GNU bitmap and mask are never freed.
7509 That way, we don't have to worry about allocating it again. */
7510 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7512 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7515 x_wm_set_icon_pixmap (f
, bitmap_id
);
7516 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7522 /* Make the x-window of frame F use a rectangle with text.
7523 Use ICON_NAME as the text. */
7526 x_text_icon (f
, icon_name
)
7530 if (FRAME_X_WINDOW (f
) == 0)
7536 text
.value
= (unsigned char *) icon_name
;
7537 text
.encoding
= XA_STRING
;
7539 text
.nitems
= strlen (icon_name
);
7540 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7542 #else /* not HAVE_X11R4 */
7543 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), icon_name
);
7544 #endif /* not HAVE_X11R4 */
7546 if (f
->output_data
.x
->icon_bitmap
> 0)
7547 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7548 f
->output_data
.x
->icon_bitmap
= 0;
7549 x_wm_set_icon_pixmap (f
, 0);
7554 #define X_ERROR_MESSAGE_SIZE 200
7556 /* If non-nil, this should be a string.
7557 It means catch X errors and store the error message in this string. */
7559 static Lisp_Object x_error_message_string
;
7561 /* An X error handler which stores the error message in
7562 x_error_message_string. This is called from x_error_handler if
7563 x_catch_errors is in effect. */
7566 x_error_catcher (display
, error
)
7570 XGetErrorText (display
, error
->error_code
,
7571 SDATA (x_error_message_string
),
7572 X_ERROR_MESSAGE_SIZE
);
7575 /* Begin trapping X errors for display DPY. Actually we trap X errors
7576 for all displays, but DPY should be the display you are actually
7579 After calling this function, X protocol errors no longer cause
7580 Emacs to exit; instead, they are recorded in the string
7581 stored in x_error_message_string.
7583 Calling x_check_errors signals an Emacs error if an X error has
7584 occurred since the last call to x_catch_errors or x_check_errors.
7586 Calling x_uncatch_errors resumes the normal error handling. */
7588 void x_check_errors ();
7589 static Lisp_Object
x_catch_errors_unwind ();
7592 x_catch_errors (dpy
)
7595 int count
= SPECPDL_INDEX ();
7597 /* Make sure any errors from previous requests have been dealt with. */
7600 record_unwind_protect (x_catch_errors_unwind
,
7601 Fcons (make_save_value (dpy
, 0),
7602 x_error_message_string
));
7604 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
7605 SSET (x_error_message_string
, 0, 0);
7610 /* Unbind the binding that we made to check for X errors. */
7613 x_catch_errors_unwind (old_val
)
7614 Lisp_Object old_val
;
7616 Lisp_Object first
= XCAR (old_val
);
7617 Display
*dpy
= XSAVE_VALUE (first
)->pointer
;
7619 /* The display may have been closed before this function is called.
7620 Check if it is still open before calling XSync. */
7621 if (x_display_info_for_display (dpy
) != 0)
7624 x_error_message_string
= XCDR (old_val
);
7628 /* If any X protocol errors have arrived since the last call to
7629 x_catch_errors or x_check_errors, signal an Emacs error using
7630 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7633 x_check_errors (dpy
, format
)
7637 /* Make sure to catch any errors incurred so far. */
7640 if (SREF (x_error_message_string
, 0))
7641 error (format
, SDATA (x_error_message_string
));
7644 /* Nonzero if we had any X protocol errors
7645 since we did x_catch_errors on DPY. */
7648 x_had_errors_p (dpy
)
7651 /* Make sure to catch any errors incurred so far. */
7654 return SREF (x_error_message_string
, 0) != 0;
7657 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7660 x_clear_errors (dpy
)
7663 SSET (x_error_message_string
, 0, 0);
7666 /* Stop catching X protocol errors and let them make Emacs die.
7667 DPY should be the display that was passed to x_catch_errors.
7668 COUNT should be the value that was returned by
7669 the corresponding call to x_catch_errors. */
7672 x_uncatch_errors (dpy
, count
)
7676 unbind_to (count
, Qnil
);
7680 static unsigned int x_wire_count
;
7683 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7688 /* Handle SIGPIPE, which can happen when the connection to a server
7689 simply goes away. SIGPIPE is handled by x_connection_signal.
7690 Don't need to do anything, because the write which caused the
7691 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7692 which will do the appropriate cleanup for us. */
7695 x_connection_signal (signalnum
) /* If we don't have an argument, */
7696 int signalnum
; /* some compilers complain in signal calls. */
7699 /* USG systems forget handlers when they are used;
7700 must reestablish each time */
7701 signal (signalnum
, x_connection_signal
);
7706 /************************************************************************
7708 ************************************************************************/
7710 /* Error message passed to x_connection_closed. */
7712 static char *error_msg
;
7714 /* Function installed as fatal_error_signal_hook in
7715 x_connection_closed. Print the X error message, and exit normally,
7716 instead of dumping core when XtCloseDisplay fails. */
7719 x_fatal_error_signal ()
7721 fprintf (stderr
, "%s\n", error_msg
);
7725 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7726 the text of an error message that lead to the connection loss. */
7729 x_connection_closed (dpy
, error_message
)
7731 char *error_message
;
7733 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7734 Lisp_Object frame
, tail
;
7737 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7738 strcpy (error_msg
, error_message
);
7739 handling_signal
= 0;
7741 /* Prevent being called recursively because of an error condition
7742 below. Otherwise, we might end up with printing ``can't find per
7743 display information'' in the recursive call instead of printing
7744 the original message here. */
7745 count
= x_catch_errors (dpy
);
7747 /* We have to close the display to inform Xt that it doesn't
7748 exist anymore. If we don't, Xt will continue to wait for
7749 events from the display. As a consequence, a sequence of
7751 M-x make-frame-on-display RET :1 RET
7752 ...kill the new frame, so that we get an IO error...
7753 M-x make-frame-on-display RET :1 RET
7755 will indefinitely wait in Xt for events for display `:1', opened
7756 in the first class to make-frame-on-display.
7758 Closing the display is reported to lead to a bus error on
7759 OpenWindows in certain situations. I suspect that is a bug
7760 in OpenWindows. I don't know how to cicumvent it here. */
7762 #ifdef USE_X_TOOLKIT
7763 /* If DPYINFO is null, this means we didn't open the display
7764 in the first place, so don't try to close it. */
7767 extern void (*fatal_error_signal_hook
) P_ ((void));
7768 fatal_error_signal_hook
= x_fatal_error_signal
;
7769 XtCloseDisplay (dpy
);
7770 fatal_error_signal_hook
= NULL
;
7776 xg_display_close (dpyinfo
->display
);
7779 /* Indicate that this display is dead. */
7781 dpyinfo
->display
= 0;
7783 /* First delete frames whose mini-buffers are on frames
7784 that are on the dead display. */
7785 FOR_EACH_FRAME (tail
, frame
)
7787 Lisp_Object minibuf_frame
;
7789 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7790 if (FRAME_X_P (XFRAME (frame
))
7791 && FRAME_X_P (XFRAME (minibuf_frame
))
7792 && ! EQ (frame
, minibuf_frame
)
7793 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7794 Fdelete_frame (frame
, Qt
);
7797 /* Now delete all remaining frames on the dead display.
7798 We are now sure none of these is used as the mini-buffer
7799 for another frame that we need to delete. */
7800 FOR_EACH_FRAME (tail
, frame
)
7801 if (FRAME_X_P (XFRAME (frame
))
7802 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7804 /* Set this to t so that Fdelete_frame won't get confused
7805 trying to find a replacement. */
7806 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7807 Fdelete_frame (frame
, Qt
);
7811 x_delete_display (dpyinfo
);
7813 x_uncatch_errors (dpy
, count
);
7815 if (x_display_list
== 0)
7817 fprintf (stderr
, "%s\n", error_msg
);
7818 shut_down_emacs (0, 0, Qnil
);
7822 /* Ordinary stack unwind doesn't deal with these. */
7824 sigunblock (sigmask (SIGIO
));
7826 sigunblock (sigmask (SIGALRM
));
7827 TOTALLY_UNBLOCK_INPUT
;
7829 clear_waiting_for_input ();
7830 error ("%s", error_msg
);
7834 /* This is the usual handler for X protocol errors.
7835 It kills all frames on the display that we got the error for.
7836 If that was the only one, it prints an error message and kills Emacs. */
7839 x_error_quitter (display
, error
)
7843 char buf
[256], buf1
[356];
7845 /* Note that there is no real way portable across R3/R4 to get the
7846 original error handler. */
7848 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7849 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7850 buf
, error
->request_code
);
7851 x_connection_closed (display
, buf1
);
7855 /* This is the first-level handler for X protocol errors.
7856 It calls x_error_quitter or x_error_catcher. */
7859 x_error_handler (display
, error
)
7863 if (! NILP (x_error_message_string
))
7864 x_error_catcher (display
, error
);
7866 x_error_quitter (display
, error
);
7870 /* This is the handler for X IO errors, always.
7871 It kills all frames on the display that we lost touch with.
7872 If that was the only one, it prints an error message and kills Emacs. */
7875 x_io_error_quitter (display
)
7880 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7881 x_connection_closed (display
, buf
);
7885 /* Changing the font of the frame. */
7887 /* Give frame F the font named FONTNAME as its default font, and
7888 return the full name of that font. FONTNAME may be a wildcard
7889 pattern; in that case, we choose some font that fits the pattern.
7890 The return value shows which font we chose. */
7893 x_new_font (f
, fontname
)
7895 register char *fontname
;
7897 struct font_info
*fontp
7898 = FS_LOAD_FONT (f
, 0, fontname
, -1);
7903 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
7904 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
7905 FRAME_FONTSET (f
) = -1;
7907 FRAME_COLUMN_WIDTH (f
) = FONT_WIDTH (FRAME_FONT (f
));
7908 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
7910 compute_fringe_widths (f
, 1);
7912 /* Compute the scroll bar width in character columns. */
7913 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7915 int wid
= FRAME_COLUMN_WIDTH (f
);
7916 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7917 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7921 int wid
= FRAME_COLUMN_WIDTH (f
);
7922 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7925 /* Now make the frame display the given font. */
7926 if (FRAME_X_WINDOW (f
) != 0)
7928 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
7929 FRAME_FONT (f
)->fid
);
7930 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
7931 FRAME_FONT (f
)->fid
);
7932 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
7933 FRAME_FONT (f
)->fid
);
7935 /* Don't change the size of a tip frame; there's no point in
7936 doing it because it's done in Fx_show_tip, and it leads to
7937 problems because the tip frame has no widget. */
7938 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7939 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7942 return build_string (fontp
->full_name
);
7945 /* Give frame F the fontset named FONTSETNAME as its default font, and
7946 return the full name of that fontset. FONTSETNAME may be a wildcard
7947 pattern; in that case, we choose some fontset that fits the pattern.
7948 The return value shows which fontset we chose. */
7951 x_new_fontset (f
, fontsetname
)
7955 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
7961 if (FRAME_FONTSET (f
) == fontset
)
7962 /* This fontset is already set in frame F. There's nothing more
7964 return fontset_name (fontset
);
7966 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
7968 if (!STRINGP (result
))
7969 /* Can't load ASCII font. */
7972 /* Since x_new_font doesn't update any fontset information, do it now. */
7973 FRAME_FONTSET (f
) = fontset
;
7977 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7978 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7981 return build_string (fontsetname
);
7985 /***********************************************************************
7987 ***********************************************************************/
7993 /* XIM destroy callback function, which is called whenever the
7994 connection to input method XIM dies. CLIENT_DATA contains a
7995 pointer to the x_display_info structure corresponding to XIM. */
7998 xim_destroy_callback (xim
, client_data
, call_data
)
8000 XPointer client_data
;
8003 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
8004 Lisp_Object frame
, tail
;
8008 /* No need to call XDestroyIC.. */
8009 FOR_EACH_FRAME (tail
, frame
)
8011 struct frame
*f
= XFRAME (frame
);
8012 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
8014 FRAME_XIC (f
) = NULL
;
8015 xic_free_xfontset (f
);
8019 /* No need to call XCloseIM. */
8020 dpyinfo
->xim
= NULL
;
8021 XFree (dpyinfo
->xim_styles
);
8025 #endif /* HAVE_X11R6 */
8028 /* This isn't prototyped in OSF 5.0 or 5.1a. */
8029 extern char *XSetIMValues
P_ ((XIM
, ...));
8032 /* Open the connection to the XIM server on display DPYINFO.
8033 RESOURCE_NAME is the resource name Emacs uses. */
8036 xim_open_dpy (dpyinfo
, resource_name
)
8037 struct x_display_info
*dpyinfo
;
8038 char *resource_name
;
8045 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
8052 XIMCallback destroy
;
8055 /* Get supported styles and XIM values. */
8056 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
8059 destroy
.callback
= xim_destroy_callback
;
8060 destroy
.client_data
= (XPointer
)dpyinfo
;
8061 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8067 #endif /* HAVE_XIM */
8068 dpyinfo
->xim
= NULL
;
8072 #ifdef HAVE_X11R6_XIM
8076 struct x_display_info
*dpyinfo
;
8077 char *resource_name
;
8080 /* XIM instantiate callback function, which is called whenever an XIM
8081 server is available. DISPLAY is the display of the XIM.
8082 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8083 when the callback was registered. */
8086 xim_instantiate_callback (display
, client_data
, call_data
)
8088 XPointer client_data
;
8091 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8092 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8094 /* We don't support multiple XIM connections. */
8098 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8100 /* Create XIC for the existing frames on the same display, as long
8101 as they have no XIC. */
8102 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8104 Lisp_Object tail
, frame
;
8107 FOR_EACH_FRAME (tail
, frame
)
8109 struct frame
*f
= XFRAME (frame
);
8111 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8112 if (FRAME_XIC (f
) == NULL
)
8114 create_frame_xic (f
);
8115 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8116 xic_set_statusarea (f
);
8117 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8119 struct window
*w
= XWINDOW (f
->selected_window
);
8120 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8129 #endif /* HAVE_X11R6_XIM */
8132 /* Open a connection to the XIM server on display DPYINFO.
8133 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8134 connection only at the first time. On X11R6, open the connection
8135 in the XIM instantiate callback function. */
8138 xim_initialize (dpyinfo
, resource_name
)
8139 struct x_display_info
*dpyinfo
;
8140 char *resource_name
;
8145 #ifdef HAVE_X11R6_XIM
8146 struct xim_inst_t
*xim_inst
;
8149 dpyinfo
->xim
= NULL
;
8150 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8151 xim_inst
->dpyinfo
= dpyinfo
;
8152 len
= strlen (resource_name
);
8153 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8154 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
8155 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8156 resource_name
, EMACS_CLASS
,
8157 xim_instantiate_callback
,
8158 /* This is XPointer in XFree86
8159 but (XPointer *) on Tru64, at
8160 least, hence the configure test. */
8161 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8162 #else /* not HAVE_X11R6_XIM */
8163 dpyinfo
->xim
= NULL
;
8164 xim_open_dpy (dpyinfo
, resource_name
);
8165 #endif /* not HAVE_X11R6_XIM */
8169 #endif /* HAVE_XIM */
8170 dpyinfo
->xim
= NULL
;
8174 /* Close the connection to the XIM server on display DPYINFO. */
8177 xim_close_dpy (dpyinfo
)
8178 struct x_display_info
*dpyinfo
;
8183 #ifdef HAVE_X11R6_XIM
8184 if (dpyinfo
->display
)
8185 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8187 xim_instantiate_callback
, NULL
);
8188 #endif /* not HAVE_X11R6_XIM */
8189 if (dpyinfo
->display
)
8190 XCloseIM (dpyinfo
->xim
);
8191 dpyinfo
->xim
= NULL
;
8192 XFree (dpyinfo
->xim_styles
);
8194 #endif /* HAVE_XIM */
8197 #endif /* not HAVE_X11R6_XIM */
8201 /* Calculate the absolute position in frame F
8202 from its current recorded position values and gravity. */
8205 x_calc_absolute_position (f
)
8208 int win_x
= 0, win_y
= 0;
8209 int flags
= f
->size_hint_flags
;
8211 /* We have nothing to do if the current position
8212 is already for the top-left corner. */
8213 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8216 /* Find the offsets of the outside upper-left corner of
8217 the inner window, with respect to the outer window.
8218 But do this only if we will need the results. */
8219 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
8220 /* This is to get *_pixels_outer_diff. */
8221 x_real_positions (f
, &win_x
, &win_y
);
8223 /* Treat negative positions as relative to the leftmost bottommost
8224 position that fits on the screen. */
8225 if (flags
& XNegative
)
8226 f
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
8227 - 2 * FRAME_X_OUTPUT (f
)->x_pixels_outer_diff
8228 - FRAME_PIXEL_WIDTH (f
)
8232 int height
= FRAME_PIXEL_HEIGHT (f
);
8234 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8235 /* Something is fishy here. When using Motif, starting Emacs with
8236 `-g -0-0', the frame appears too low by a few pixels.
8238 This seems to be so because initially, while Emacs is starting,
8239 the column widget's height and the frame's pixel height are
8240 different. The column widget's height is the right one. In
8241 later invocations, when Emacs is up, the frame's pixel height
8244 It's not obvious where the initial small difference comes from.
8245 2000-12-01, gerd. */
8247 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8250 if (flags
& YNegative
)
8251 f
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
8252 - FRAME_X_OUTPUT (f
)->y_pixels_outer_diff
8254 /* Assume the window manager decorations are the same size on
8255 three sides, i.e. left, right and bottom. This is to
8256 compensate for the bottom part. */
8257 - FRAME_X_OUTPUT (f
)->x_pixels_outer_diff
8262 /* The left_pos and top_pos
8263 are now relative to the top and left screen edges,
8264 so the flags should correspond. */
8265 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8268 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8269 to really change the position, and 0 when calling from
8270 x_make_frame_visible (in that case, XOFF and YOFF are the current
8271 position values). It is -1 when calling from x_set_frame_parameters,
8272 which means, do adjust for borders but don't change the gravity. */
8275 x_set_offset (f
, xoff
, yoff
, change_gravity
)
8277 register int xoff
, yoff
;
8280 int modified_top
, modified_left
;
8282 if (change_gravity
> 0)
8286 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8288 f
->size_hint_flags
|= XNegative
;
8290 f
->size_hint_flags
|= YNegative
;
8291 f
->win_gravity
= NorthWestGravity
;
8293 x_calc_absolute_position (f
);
8296 x_wm_set_size_hint (f
, (long) 0, 0);
8298 modified_left
= f
->left_pos
;
8299 modified_top
= f
->top_pos
;
8301 if (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8303 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8304 than the WM decorations. So we use the calculated offset instead
8305 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8306 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8307 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8310 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8311 modified_left
, modified_top
);
8313 if (FRAME_VISIBLE_P (f
)
8314 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
)
8316 FRAME_X_OUTPUT (f
)->check_expected_move
= 1;
8317 FRAME_X_OUTPUT (f
)->expected_top
= f
->top_pos
;
8318 FRAME_X_OUTPUT (f
)->expected_left
= f
->left_pos
;
8324 /* Check if we need to resize the frame due to a fullscreen request.
8325 If so needed, resize the frame. */
8327 x_check_fullscreen (f
)
8330 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
8332 int width
, height
, ign
;
8334 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8336 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
8338 /* We do not need to move the window, it shall be taken care of
8339 when setting WM manager hints.
8340 If the frame is visible already, the position is checked by
8341 x_check_expected_move. */
8342 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8344 change_frame_size (f
, height
, width
, 0, 1, 0);
8345 SET_FRAME_GARBAGED (f
);
8346 cancel_mouse_face (f
);
8348 /* Wait for the change of frame size to occur */
8349 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
8354 /* If frame parameters are set after the frame is mapped, we need to move
8356 Some window managers moves the window to the right position, some
8357 moves the outer window manager window to the specified position.
8358 Here we check that we are in the right spot. If not, make a second
8359 move, assuming we are dealing with the second kind of window manager. */
8361 x_check_expected_move (f
)
8364 if (FRAME_X_OUTPUT (f
)->check_expected_move
)
8366 int expect_top
= FRAME_X_OUTPUT (f
)->expected_top
;
8367 int expect_left
= FRAME_X_OUTPUT (f
)->expected_left
;
8369 if (expect_top
!= f
->top_pos
|| expect_left
!= f
->left_pos
)
8371 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8372 FRAME_X_OUTPUT (f
)->move_offset_left
= expect_left
- f
->left_pos
;
8373 FRAME_X_OUTPUT (f
)->move_offset_top
= expect_top
- f
->top_pos
;
8375 x_set_offset (f
, expect_left
, expect_top
, 1);
8377 else if (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
)
8378 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8380 /* Just do this once */
8381 FRAME_X_OUTPUT (f
)->check_expected_move
= 0;
8386 /* Change the size of frame F's X window to COLS/ROWS in the case F
8387 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8388 top-left-corner window gravity for this size change and subsequent
8389 size changes. Otherwise we leave the window gravity unchanged. */
8392 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
8397 int pixelwidth
, pixelheight
;
8399 check_frame_size (f
, &rows
, &cols
);
8400 f
->scroll_bar_actual_width
8401 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8403 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
8404 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
8405 : (FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
)));
8407 compute_fringe_widths (f
, 0);
8409 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
8410 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
8412 f
->win_gravity
= NorthWestGravity
;
8413 x_wm_set_size_hint (f
, (long) 0, 0);
8415 XSync (FRAME_X_DISPLAY (f
), False
);
8416 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8417 pixelwidth
, pixelheight
);
8419 /* Now, strictly speaking, we can't be sure that this is accurate,
8420 but the window manager will get around to dealing with the size
8421 change request eventually, and we'll hear how it went when the
8422 ConfigureNotify event gets here.
8424 We could just not bother storing any of this information here,
8425 and let the ConfigureNotify event set everything up, but that
8426 might be kind of confusing to the Lisp code, since size changes
8427 wouldn't be reported in the frame parameters until some random
8428 point in the future when the ConfigureNotify event arrives.
8430 We pass 1 for DELAY since we can't run Lisp code inside of
8432 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8433 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8434 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8436 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8437 receive in the ConfigureNotify event; if we get what we asked
8438 for, then the event won't cause the screen to become garbaged, so
8439 we have to make sure to do it here. */
8440 SET_FRAME_GARBAGED (f
);
8442 XFlush (FRAME_X_DISPLAY (f
));
8446 /* Call this to change the size of frame F's x-window.
8447 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8448 for this size change and subsequent size changes.
8449 Otherwise we leave the window gravity unchanged. */
8452 x_set_window_size (f
, change_gravity
, cols
, rows
)
8460 if (FRAME_GTK_WIDGET (f
))
8461 xg_frame_set_char_size (f
, cols
, rows
);
8463 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8466 if (f
->output_data
.x
->widget
!= NULL
)
8468 /* The x and y position of the widget is clobbered by the
8469 call to XtSetValues within EmacsFrameSetCharSize.
8470 This is a real kludge, but I don't understand Xt so I can't
8471 figure out a correct fix. Can anyone else tell me? -- rms. */
8472 int xpos
= f
->output_data
.x
->widget
->core
.x
;
8473 int ypos
= f
->output_data
.x
->widget
->core
.y
;
8474 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
8475 f
->output_data
.x
->widget
->core
.x
= xpos
;
8476 f
->output_data
.x
->widget
->core
.y
= ypos
;
8479 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8481 #else /* not USE_X_TOOLKIT */
8483 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8485 #endif /* not USE_X_TOOLKIT */
8487 /* If cursor was outside the new size, mark it as off. */
8488 mark_window_cursors_off (XWINDOW (f
->root_window
));
8490 /* Clear out any recollection of where the mouse highlighting was,
8491 since it might be in a place that's outside the new frame size.
8492 Actually checking whether it is outside is a pain in the neck,
8493 so don't try--just let the highlighting be done afresh with new size. */
8494 cancel_mouse_face (f
);
8499 /* Mouse warping. */
8502 x_set_mouse_position (f
, x
, y
)
8508 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8509 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8511 if (pix_x
< 0) pix_x
= 0;
8512 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8514 if (pix_y
< 0) pix_y
= 0;
8515 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8519 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8520 0, 0, 0, 0, pix_x
, pix_y
);
8524 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8527 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
8533 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8534 0, 0, 0, 0, pix_x
, pix_y
);
8538 /* focus shifting, raising and lowering. */
8541 x_focus_on_frame (f
)
8544 #if 0 /* This proves to be unpleasant. */
8548 /* I don't think that the ICCCM allows programs to do things like this
8549 without the interaction of the window manager. Whatever you end up
8550 doing with this code, do it to x_unfocus_frame too. */
8551 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8552 RevertToPointerRoot
, CurrentTime
);
8561 /* Look at the remarks in x_focus_on_frame. */
8562 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8563 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8564 RevertToPointerRoot
, CurrentTime
);
8568 /* Raise frame F. */
8574 if (f
->async_visible
)
8577 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8578 XFlush (FRAME_X_DISPLAY (f
));
8583 /* Lower frame F. */
8589 if (f
->async_visible
)
8592 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8593 XFlush (FRAME_X_DISPLAY (f
));
8599 XTframe_raise_lower (f
, raise_flag
)
8609 /* Change of visibility. */
8611 /* This tries to wait until the frame is really visible.
8612 However, if the window manager asks the user where to position
8613 the frame, this will return before the user finishes doing that.
8614 The frame will not actually be visible at that time,
8615 but it will become visible later when the window manager
8616 finishes with it. */
8619 x_make_frame_visible (f
)
8623 int original_top
, original_left
;
8624 int retry_count
= 2;
8630 type
= x_icon_type (f
);
8632 x_bitmap_icon (f
, type
);
8634 if (! FRAME_VISIBLE_P (f
))
8636 /* We test FRAME_GARBAGED_P here to make sure we don't
8637 call x_set_offset a second time
8638 if we get to x_make_frame_visible a second time
8639 before the window gets really visible. */
8640 if (! FRAME_ICONIFIED_P (f
)
8641 && ! f
->output_data
.x
->asked_for_visible
)
8642 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8644 f
->output_data
.x
->asked_for_visible
= 1;
8646 if (! EQ (Vx_no_window_manager
, Qt
))
8647 x_wm_set_window_state (f
, NormalState
);
8648 #ifdef USE_X_TOOLKIT
8649 /* This was XtPopup, but that did nothing for an iconified frame. */
8650 XtMapWidget (f
->output_data
.x
->widget
);
8651 #else /* not USE_X_TOOLKIT */
8653 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8654 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8656 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8657 #endif /* not USE_GTK */
8658 #endif /* not USE_X_TOOLKIT */
8659 #if 0 /* This seems to bring back scroll bars in the wrong places
8660 if the window configuration has changed. They seem
8661 to come back ok without this. */
8662 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8663 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8667 XFlush (FRAME_X_DISPLAY (f
));
8669 /* Synchronize to ensure Emacs knows the frame is visible
8670 before we do anything else. We do this loop with input not blocked
8671 so that incoming events are handled. */
8675 /* This must be before UNBLOCK_INPUT
8676 since events that arrive in response to the actions above
8677 will set it when they are handled. */
8678 int previously_visible
= f
->output_data
.x
->has_been_visible
;
8680 original_left
= f
->left_pos
;
8681 original_top
= f
->top_pos
;
8683 /* This must come after we set COUNT. */
8686 /* We unblock here so that arriving X events are processed. */
8688 /* Now move the window back to where it was "supposed to be".
8689 But don't do it if the gravity is negative.
8690 When the gravity is negative, this uses a position
8691 that is 3 pixels too low. Perhaps that's really the border width.
8693 Don't do this if the window has never been visible before,
8694 because the window manager may choose the position
8695 and we don't want to override it. */
8697 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
8698 && f
->win_gravity
== NorthWestGravity
8699 && previously_visible
)
8703 unsigned int width
, height
, border
, depth
;
8707 /* On some window managers (such as FVWM) moving an existing
8708 window, even to the same place, causes the window manager
8709 to introduce an offset. This can cause the window to move
8710 to an unexpected location. Check the geometry (a little
8711 slow here) and then verify that the window is in the right
8712 place. If the window is not in the right place, move it
8713 there, and take the potential window manager hit. */
8714 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8715 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
8717 if (original_left
!= x
|| original_top
!= y
)
8718 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8719 original_left
, original_top
);
8724 XSETFRAME (frame
, f
);
8726 /* Wait until the frame is visible. Process X events until a
8727 MapNotify event has been seen, or until we think we won't get a
8728 MapNotify at all.. */
8729 for (count
= input_signal_count
+ 10;
8730 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
8732 /* Force processing of queued events. */
8735 /* Machines that do polling rather than SIGIO have been
8736 observed to go into a busy-wait here. So we'll fake an
8737 alarm signal to let the handler know that there's something
8738 to be read. We used to raise a real alarm, but it seems
8739 that the handler isn't always enabled here. This is
8741 if (input_polling_used ())
8743 /* It could be confusing if a real alarm arrives while
8744 processing the fake one. Turn it off and let the
8745 handler reset it. */
8746 extern void poll_for_input_1
P_ ((void));
8747 int old_poll_suppress_count
= poll_suppress_count
;
8748 poll_suppress_count
= 1;
8749 poll_for_input_1 ();
8750 poll_suppress_count
= old_poll_suppress_count
;
8753 /* See if a MapNotify event has been processed. */
8754 FRAME_SAMPLE_VISIBILITY (f
);
8759 (let ((f (selected-frame)))
8763 the frame is not raised with various window managers on
8764 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
8765 unknown reason, the call to XtMapWidget is completely ignored.
8766 Mapping the widget a second time works. */
8768 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
8773 /* Change from mapped state to withdrawn state. */
8775 /* Make the frame visible (mapped and not iconified). */
8778 x_make_frame_invisible (f
)
8783 /* Use the frame's outermost window, not the one we normally draw on. */
8784 window
= FRAME_OUTER_WINDOW (f
);
8786 /* Don't keep the highlight on an invisible frame. */
8787 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
8788 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
8790 #if 0/* This might add unreliability; I don't trust it -- rms. */
8791 if (! f
->async_visible
&& ! f
->async_iconified
)
8797 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
8798 that the current position of the window is user-specified, rather than
8799 program-specified, so that when the window is mapped again, it will be
8800 placed at the same location, without forcing the user to position it
8801 by hand again (they have already done that once for this window.) */
8802 x_wm_set_size_hint (f
, (long) 0, 1);
8805 if (FRAME_GTK_OUTER_WIDGET (f
))
8806 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
8812 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
8813 DefaultScreen (FRAME_X_DISPLAY (f
))))
8815 UNBLOCK_INPUT_RESIGNAL
;
8816 error ("Can't notify window manager of window withdrawal");
8818 #else /* ! defined (HAVE_X11R4) */
8820 /* Tell the window manager what we're going to do. */
8821 if (! EQ (Vx_no_window_manager
, Qt
))
8825 unmap
.xunmap
.type
= UnmapNotify
;
8826 unmap
.xunmap
.window
= window
;
8827 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
8828 unmap
.xunmap
.from_configure
= False
;
8829 if (! XSendEvent (FRAME_X_DISPLAY (f
),
8830 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
8832 SubstructureRedirectMaskSubstructureNotifyMask
,
8835 UNBLOCK_INPUT_RESIGNAL
;
8836 error ("Can't notify window manager of withdrawal");
8840 /* Unmap the window ourselves. Cheeky! */
8841 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
8842 #endif /* ! defined (HAVE_X11R4) */
8845 /* We can't distinguish this from iconification
8846 just by the event that we get from the server.
8847 So we can't win using the usual strategy of letting
8848 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
8849 and synchronize with the server to make sure we agree. */
8851 FRAME_ICONIFIED_P (f
) = 0;
8852 f
->async_visible
= 0;
8853 f
->async_iconified
= 0;
8860 /* Change window state from mapped to iconified. */
8869 /* Don't keep the highlight on an invisible frame. */
8870 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
8871 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
8873 if (f
->async_iconified
)
8878 FRAME_SAMPLE_VISIBILITY (f
);
8880 type
= x_icon_type (f
);
8882 x_bitmap_icon (f
, type
);
8885 if (FRAME_GTK_OUTER_WIDGET (f
))
8887 if (! FRAME_VISIBLE_P (f
))
8888 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8890 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8893 f
->async_iconified
= 1;
8894 f
->async_visible
= 0;
8900 #ifdef USE_X_TOOLKIT
8902 if (! FRAME_VISIBLE_P (f
))
8904 if (! EQ (Vx_no_window_manager
, Qt
))
8905 x_wm_set_window_state (f
, IconicState
);
8906 /* This was XtPopup, but that did nothing for an iconified frame. */
8907 XtMapWidget (f
->output_data
.x
->widget
);
8908 /* The server won't give us any event to indicate
8909 that an invisible frame was changed to an icon,
8910 so we have to record it here. */
8913 f
->async_iconified
= 1;
8914 f
->async_visible
= 0;
8919 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
8920 XtWindow (f
->output_data
.x
->widget
),
8921 DefaultScreen (FRAME_X_DISPLAY (f
)));
8925 error ("Can't notify window manager of iconification");
8927 f
->async_iconified
= 1;
8928 f
->async_visible
= 0;
8932 XFlush (FRAME_X_DISPLAY (f
));
8934 #else /* not USE_X_TOOLKIT */
8936 /* Make sure the X server knows where the window should be positioned,
8937 in case the user deiconifies with the window manager. */
8938 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
8939 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8941 /* Since we don't know which revision of X we're running, we'll use both
8942 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
8944 /* X11R4: send a ClientMessage to the window manager using the
8945 WM_CHANGE_STATE type. */
8949 message
.xclient
.window
= FRAME_X_WINDOW (f
);
8950 message
.xclient
.type
= ClientMessage
;
8951 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
8952 message
.xclient
.format
= 32;
8953 message
.xclient
.data
.l
[0] = IconicState
;
8955 if (! XSendEvent (FRAME_X_DISPLAY (f
),
8956 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
8958 SubstructureRedirectMask
| SubstructureNotifyMask
,
8961 UNBLOCK_INPUT_RESIGNAL
;
8962 error ("Can't notify window manager of iconification");
8966 /* X11R3: set the initial_state field of the window manager hints to
8968 x_wm_set_window_state (f
, IconicState
);
8970 if (!FRAME_VISIBLE_P (f
))
8972 /* If the frame was withdrawn, before, we must map it. */
8973 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8976 f
->async_iconified
= 1;
8977 f
->async_visible
= 0;
8979 XFlush (FRAME_X_DISPLAY (f
));
8981 #endif /* not USE_X_TOOLKIT */
8985 /* Free X resources of frame F. */
8988 x_free_frame_resources (f
)
8991 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8993 struct scroll_bar
*b
;
8997 /* If a display connection is dead, don't try sending more
8998 commands to the X server. */
8999 if (dpyinfo
->display
)
9001 if (f
->output_data
.x
->icon_desc
)
9002 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9004 #ifdef USE_X_TOOLKIT
9005 /* Explicitly destroy the scroll bars of the frame. Without
9006 this, we get "BadDrawable" errors from the toolkit later on,
9007 presumably from expose events generated for the disappearing
9008 toolkit scroll bars. */
9009 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9011 b
= XSCROLL_BAR (bar
);
9012 x_scroll_bar_remove (b
);
9021 #ifdef USE_X_TOOLKIT
9022 if (f
->output_data
.x
->widget
)
9024 XtDestroyWidget (f
->output_data
.x
->widget
);
9025 f
->output_data
.x
->widget
= NULL
;
9027 /* Tooltips don't have widgets, only a simple X window, even if
9028 we are using a toolkit. */
9029 else if (FRAME_X_WINDOW (f
))
9030 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9032 free_frame_menubar (f
);
9033 #else /* !USE_X_TOOLKIT */
9036 /* In the GTK version, tooltips are normal X
9037 frames. We must check and free both types. */
9038 if (FRAME_GTK_OUTER_WIDGET (f
))
9040 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
9041 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow below */
9042 FRAME_GTK_OUTER_WIDGET (f
) = 0;
9044 #endif /* USE_GTK */
9046 if (FRAME_X_WINDOW (f
))
9047 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9048 #endif /* !USE_X_TOOLKIT */
9050 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
9051 unload_color (f
, f
->output_data
.x
->background_pixel
);
9052 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9053 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9054 unload_color (f
, f
->output_data
.x
->border_pixel
);
9055 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9057 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9058 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9059 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9060 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9061 #ifdef USE_TOOLKIT_SCROLL_BARS
9062 /* Scrollbar shadow colors. */
9063 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9064 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9065 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9066 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9067 #endif /* USE_TOOLKIT_SCROLL_BARS */
9068 if (f
->output_data
.x
->white_relief
.allocated_p
)
9069 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9070 if (f
->output_data
.x
->black_relief
.allocated_p
)
9071 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9073 if (FRAME_FACE_CACHE (f
))
9074 free_frame_faces (f
);
9077 XFlush (FRAME_X_DISPLAY (f
));
9080 if (f
->output_data
.x
->saved_menu_event
)
9081 xfree (f
->output_data
.x
->saved_menu_event
);
9083 xfree (f
->output_data
.x
);
9084 f
->output_data
.x
= NULL
;
9086 if (f
== dpyinfo
->x_focus_frame
)
9087 dpyinfo
->x_focus_frame
= 0;
9088 if (f
== dpyinfo
->x_focus_event_frame
)
9089 dpyinfo
->x_focus_event_frame
= 0;
9090 if (f
== dpyinfo
->x_highlight_frame
)
9091 dpyinfo
->x_highlight_frame
= 0;
9093 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9095 dpyinfo
->mouse_face_beg_row
9096 = dpyinfo
->mouse_face_beg_col
= -1;
9097 dpyinfo
->mouse_face_end_row
9098 = dpyinfo
->mouse_face_end_col
= -1;
9099 dpyinfo
->mouse_face_window
= Qnil
;
9100 dpyinfo
->mouse_face_deferred_gc
= 0;
9101 dpyinfo
->mouse_face_mouse_frame
= 0;
9108 /* Destroy the X window of frame F. */
9111 x_destroy_window (f
)
9114 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9116 /* If a display connection is dead, don't try sending more
9117 commands to the X server. */
9118 if (dpyinfo
->display
!= 0)
9119 x_free_frame_resources (f
);
9121 dpyinfo
->reference_count
--;
9125 /* Setting window manager hints. */
9127 /* Set the normal size hints for the window manager, for frame F.
9128 FLAGS is the flags word to use--or 0 meaning preserve the flags
9129 that the window now has.
9130 If USER_POSITION is nonzero, we set the USPosition
9131 flag (this is useful when FLAGS is 0).
9132 The GTK version is in gtkutils.c */
9136 x_wm_set_size_hint (f
, flags
, user_position
)
9141 XSizeHints size_hints
;
9143 #ifdef USE_X_TOOLKIT
9146 Dimension widget_width
, widget_height
;
9149 Window window
= FRAME_OUTER_WINDOW (f
);
9151 /* Setting PMaxSize caused various problems. */
9152 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9154 size_hints
.x
= f
->left_pos
;
9155 size_hints
.y
= f
->top_pos
;
9157 #ifdef USE_X_TOOLKIT
9158 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
9159 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
9160 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
9161 size_hints
.height
= widget_height
;
9162 size_hints
.width
= widget_width
;
9163 #else /* not USE_X_TOOLKIT */
9164 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9165 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9166 #endif /* not USE_X_TOOLKIT */
9168 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9169 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9170 size_hints
.max_width
9171 = FRAME_X_DISPLAY_INFO (f
)->width
- FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9172 size_hints
.max_height
9173 = FRAME_X_DISPLAY_INFO (f
)->height
- FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9175 /* Calculate the base and minimum sizes.
9177 (When we use the X toolkit, we don't do it here.
9178 Instead we copy the values that the widgets are using, below.) */
9179 #ifndef USE_X_TOOLKIT
9181 int base_width
, base_height
;
9182 int min_rows
= 0, min_cols
= 0;
9184 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9185 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9187 check_frame_size (f
, &min_rows
, &min_cols
);
9189 /* The window manager uses the base width hints to calculate the
9190 current number of rows and columns in the frame while
9191 resizing; min_width and min_height aren't useful for this
9192 purpose, since they might not give the dimensions for a
9193 zero-row, zero-column frame.
9195 We use the base_width and base_height members if we have
9196 them; otherwise, we set the min_width and min_height members
9197 to the size for a zero x zero frame. */
9200 size_hints
.flags
|= PBaseSize
;
9201 size_hints
.base_width
= base_width
;
9202 size_hints
.base_height
= base_height
;
9203 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9204 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9206 size_hints
.min_width
= base_width
;
9207 size_hints
.min_height
= base_height
;
9211 /* If we don't need the old flags, we don't need the old hint at all. */
9214 size_hints
.flags
|= flags
;
9217 #endif /* not USE_X_TOOLKIT */
9220 XSizeHints hints
; /* Sometimes I hate X Windows... */
9221 long supplied_return
;
9225 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9228 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
9231 #ifdef USE_X_TOOLKIT
9232 size_hints
.base_height
= hints
.base_height
;
9233 size_hints
.base_width
= hints
.base_width
;
9234 size_hints
.min_height
= hints
.min_height
;
9235 size_hints
.min_width
= hints
.min_width
;
9239 size_hints
.flags
|= flags
;
9244 if (hints
.flags
& PSize
)
9245 size_hints
.flags
|= PSize
;
9246 if (hints
.flags
& PPosition
)
9247 size_hints
.flags
|= PPosition
;
9248 if (hints
.flags
& USPosition
)
9249 size_hints
.flags
|= USPosition
;
9250 if (hints
.flags
& USSize
)
9251 size_hints
.flags
|= USSize
;
9255 #ifndef USE_X_TOOLKIT
9260 size_hints
.win_gravity
= f
->win_gravity
;
9261 size_hints
.flags
|= PWinGravity
;
9265 size_hints
.flags
&= ~ PPosition
;
9266 size_hints
.flags
|= USPosition
;
9268 #endif /* PWinGravity */
9271 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9273 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9276 #endif /* not USE_GTK */
9278 /* Used for IconicState or NormalState */
9281 x_wm_set_window_state (f
, state
)
9285 #ifdef USE_X_TOOLKIT
9288 XtSetArg (al
[0], XtNinitialState
, state
);
9289 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9290 #else /* not USE_X_TOOLKIT */
9291 Window window
= FRAME_X_WINDOW (f
);
9293 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9294 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9296 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9297 #endif /* not USE_X_TOOLKIT */
9301 x_wm_set_icon_pixmap (f
, pixmap_id
)
9305 Pixmap icon_pixmap
, icon_mask
;
9307 #ifndef USE_X_TOOLKIT
9308 Window window
= FRAME_OUTER_WINDOW (f
);
9313 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9314 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9315 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9316 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9320 /* It seems there is no way to turn off use of an icon pixmap.
9321 The following line does it, only if no icon has yet been created,
9322 for some window managers. But with mwm it crashes.
9323 Some people say it should clear the IconPixmapHint bit in this case,
9324 but that doesn't work, and the X consortium said it isn't the
9325 right thing at all. Since there is no way to win,
9326 best to explicitly give up. */
9328 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
9329 f
->output_data
.x
->wm_hints
.icon_mask
= None
;
9335 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
9339 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9340 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9341 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9342 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9345 #else /* not USE_X_TOOLKIT */
9347 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9348 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9350 #endif /* not USE_X_TOOLKIT */
9354 x_wm_set_icon_position (f
, icon_x
, icon_y
)
9358 Window window
= FRAME_OUTER_WINDOW (f
);
9360 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9361 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9362 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9364 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9368 /***********************************************************************
9370 ***********************************************************************/
9372 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
9375 x_get_font_info (f
, font_idx
)
9379 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
9383 /* Return a list of names of available fonts matching PATTERN on frame F.
9385 If SIZE is > 0, it is the size (maximum bounds width) of fonts
9388 SIZE < 0 means include scalable fonts.
9390 Frame F null means we have not yet created any frame on X, and
9391 consult the first display in x_display_list. MAXNAMES sets a limit
9392 on how many fonts to match. */
9395 x_list_fonts (f
, pattern
, size
, maxnames
)
9397 Lisp_Object pattern
;
9401 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
9402 Lisp_Object tem
, second_best
;
9403 struct x_display_info
*dpyinfo
9404 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
9405 Display
*dpy
= dpyinfo
->display
;
9406 int try_XLoadQueryFont
= 0;
9408 int allow_auto_scaled_font
= 0;
9412 allow_auto_scaled_font
= 1;
9416 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
9417 if (NILP (patterns
))
9418 patterns
= Fcons (pattern
, Qnil
);
9420 if (maxnames
== 1 && !size
)
9421 /* We can return any single font matching PATTERN. */
9422 try_XLoadQueryFont
= 1;
9424 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
9427 char **names
= NULL
;
9429 pattern
= XCAR (patterns
);
9430 /* See if we cached the result for this particular query.
9431 The cache is an alist of the form:
9432 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
9433 tem
= XCDR (dpyinfo
->name_list_element
);
9434 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
9435 allow_auto_scaled_font
? Qt
: Qnil
);
9436 list
= Fassoc (key
, tem
);
9439 list
= Fcdr_safe (list
);
9440 /* We have a cashed list. Don't have to get the list again. */
9444 /* At first, put PATTERN in the cache. */
9447 count
= x_catch_errors (dpy
);
9449 if (try_XLoadQueryFont
)
9452 unsigned long value
;
9454 font
= XLoadQueryFont (dpy
, SDATA (pattern
));
9455 if (x_had_errors_p (dpy
))
9457 /* This error is perhaps due to insufficient memory on X
9458 server. Let's just ignore it. */
9460 x_clear_errors (dpy
);
9464 && XGetFontProperty (font
, XA_FONT
, &value
))
9466 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
9467 int len
= strlen (name
);
9470 /* If DXPC (a Differential X Protocol Compressor)
9471 Ver.3.7 is running, XGetAtomName will return null
9472 string. We must avoid such a name. */
9474 try_XLoadQueryFont
= 0;
9478 names
= (char **) alloca (sizeof (char *));
9479 /* Some systems only allow alloca assigned to a
9481 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
9482 bcopy (name
, names
[0], len
+ 1);
9487 try_XLoadQueryFont
= 0;
9490 XFreeFont (dpy
, font
);
9493 if (!try_XLoadQueryFont
)
9495 /* We try at least 10 fonts because XListFonts will return
9496 auto-scaled fonts at the head. */
9503 names
= XListFonts (dpy
, SDATA (pattern
), limit
, &num_fonts
);
9504 if (num_fonts
== limit
)
9507 XFreeFontNames (names
);
9516 names
= XListFonts (dpy
, SDATA (pattern
), max (maxnames
, 10),
9519 if (x_had_errors_p (dpy
))
9521 /* This error is perhaps due to insufficient memory on X
9522 server. Let's just ignore it. */
9524 x_clear_errors (dpy
);
9528 x_uncatch_errors (dpy
, count
);
9535 /* Make a list of all the fonts we got back.
9536 Store that in the font cache for the display. */
9537 for (i
= 0; i
< num_fonts
; i
++)
9541 int average_width
= -1, resx
= 0, dashes
= 0;
9543 /* Count the number of dashes in NAMES[I]. If there are
9544 14 dashes, the field value following 9th dash
9545 (RESOLUTION_X) is nonzero, and the field value
9546 following 12th dash (AVERAGE_WIDTH) is 0, this is a
9547 auto-scaled font which is usually too ugly to be used
9548 for editing. Let's ignore it. */
9553 if (dashes
== 7) /* PIXEL_SIZE field */
9555 else if (dashes
== 9)
9557 else if (dashes
== 12) /* AVERAGE_WIDTH field */
9558 average_width
= atoi (p
);
9561 if (allow_auto_scaled_font
9562 || dashes
< 14 || average_width
!= 0 || resx
== 0)
9564 tem
= build_string (names
[i
]);
9565 if (NILP (Fassoc (tem
, list
)))
9567 if (STRINGP (Vx_pixel_size_width_font_regexp
)
9568 && ((fast_c_string_match_ignore_case
9569 (Vx_pixel_size_width_font_regexp
, names
[i
]))
9571 /* We can set the value of PIXEL_SIZE to the
9572 width of this font. */
9573 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
9575 /* For the moment, width is not known. */
9576 list
= Fcons (Fcons (tem
, Qnil
), list
);
9581 if (!try_XLoadQueryFont
)
9584 XFreeFontNames (names
);
9589 /* Now store the result in the cache. */
9590 XSETCDR (dpyinfo
->name_list_element
,
9591 Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
)));
9594 if (NILP (list
)) continue; /* Try the remaining alternatives. */
9596 newlist
= second_best
= Qnil
;
9597 /* Make a list of the fonts that have the right width. */
9598 for (; CONSP (list
); list
= XCDR (list
))
9604 if (!CONSP (tem
) || NILP (XCAR (tem
)))
9608 newlist
= Fcons (XCAR (tem
), newlist
);
9612 if (!INTEGERP (XCDR (tem
)))
9614 /* Since we have not yet known the size of this font, we
9615 must try slow function call XLoadQueryFont. */
9616 XFontStruct
*thisinfo
;
9619 count
= x_catch_errors (dpy
);
9620 thisinfo
= XLoadQueryFont (dpy
,
9621 SDATA (XCAR (tem
)));
9622 if (x_had_errors_p (dpy
))
9624 /* This error is perhaps due to insufficient memory on X
9625 server. Let's just ignore it. */
9627 x_clear_errors (dpy
);
9629 x_uncatch_errors (dpy
, count
);
9635 (thisinfo
->min_bounds
.width
== 0
9637 : make_number (thisinfo
->max_bounds
.width
)));
9639 XFreeFont (dpy
, thisinfo
);
9643 /* For unknown reason, the previous call of XListFont had
9644 returned a font which can't be opened. Record the size
9645 as 0 not to try to open it again. */
9646 XSETCDR (tem
, make_number (0));
9649 found_size
= XINT (XCDR (tem
));
9650 if (found_size
== size
)
9651 newlist
= Fcons (XCAR (tem
), newlist
);
9652 else if (found_size
> 0)
9654 if (NILP (second_best
))
9656 else if (found_size
< size
)
9658 if (XINT (XCDR (second_best
)) > size
9659 || XINT (XCDR (second_best
)) < found_size
)
9664 if (XINT (XCDR (second_best
)) > size
9665 && XINT (XCDR (second_best
)) > found_size
)
9670 if (!NILP (newlist
))
9672 else if (!NILP (second_best
))
9674 newlist
= Fcons (XCAR (second_best
), Qnil
);
9685 /* Check that FONT is valid on frame F. It is if it can be found in F's
9689 x_check_font (f
, font
)
9694 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9696 xassert (font
!= NULL
);
9698 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9699 if (dpyinfo
->font_table
[i
].name
9700 && font
== dpyinfo
->font_table
[i
].font
)
9703 xassert (i
< dpyinfo
->n_fonts
);
9706 #endif /* GLYPH_DEBUG != 0 */
9708 /* Set *W to the minimum width, *H to the minimum font height of FONT.
9709 Note: There are (broken) X fonts out there with invalid XFontStruct
9710 min_bounds contents. For example, handa@etl.go.jp reports that
9711 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
9712 have font->min_bounds.width == 0. */
9715 x_font_min_bounds (font
, w
, h
)
9719 *h
= FONT_HEIGHT (font
);
9720 *w
= font
->min_bounds
.width
;
9722 /* Try to handle the case where FONT->min_bounds has invalid
9723 contents. Since the only font known to have invalid min_bounds
9724 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
9726 *w
= font
->max_bounds
.width
;
9730 /* Compute the smallest character width and smallest font height over
9731 all fonts available on frame F. Set the members smallest_char_width
9732 and smallest_font_height in F's x_display_info structure to
9733 the values computed. Value is non-zero if smallest_font_height or
9734 smallest_char_width become smaller than they were before. */
9737 x_compute_min_glyph_bounds (f
)
9741 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9743 int old_width
= dpyinfo
->smallest_char_width
;
9744 int old_height
= dpyinfo
->smallest_font_height
;
9746 dpyinfo
->smallest_font_height
= 100000;
9747 dpyinfo
->smallest_char_width
= 100000;
9749 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9750 if (dpyinfo
->font_table
[i
].name
)
9752 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
9755 font
= (XFontStruct
*) fontp
->font
;
9756 xassert (font
!= (XFontStruct
*) ~0);
9757 x_font_min_bounds (font
, &w
, &h
);
9759 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
9760 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
9763 xassert (dpyinfo
->smallest_char_width
> 0
9764 && dpyinfo
->smallest_font_height
> 0);
9766 return (dpyinfo
->n_fonts
== 1
9767 || dpyinfo
->smallest_char_width
< old_width
9768 || dpyinfo
->smallest_font_height
< old_height
);
9772 /* Load font named FONTNAME of the size SIZE for frame F, and return a
9773 pointer to the structure font_info while allocating it dynamically.
9774 If SIZE is 0, load any size of font.
9775 If loading is failed, return NULL. */
9778 x_load_font (f
, fontname
, size
)
9780 register char *fontname
;
9783 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9784 Lisp_Object font_names
;
9787 /* Get a list of all the fonts that match this name. Once we
9788 have a list of matching fonts, we compare them against the fonts
9789 we already have by comparing names. */
9790 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
9792 if (!NILP (font_names
))
9797 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9798 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
9799 if (dpyinfo
->font_table
[i
].name
9800 && (!strcmp (dpyinfo
->font_table
[i
].name
,
9801 SDATA (XCAR (tail
)))
9802 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
9803 SDATA (XCAR (tail
)))))
9804 return (dpyinfo
->font_table
+ i
);
9807 /* Load the font and add it to the table. */
9811 struct font_info
*fontp
;
9812 unsigned long value
;
9815 /* If we have found fonts by x_list_font, load one of them. If
9816 not, we still try to load a font by the name given as FONTNAME
9817 because XListFonts (called in x_list_font) of some X server has
9818 a bug of not finding a font even if the font surely exists and
9819 is loadable by XLoadQueryFont. */
9820 if (size
> 0 && !NILP (font_names
))
9821 fontname
= (char *) SDATA (XCAR (font_names
));
9824 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
9825 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
9826 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
9828 /* This error is perhaps due to insufficient memory on X
9829 server. Let's just ignore it. */
9831 x_clear_errors (FRAME_X_DISPLAY (f
));
9833 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
9838 /* Find a free slot in the font table. */
9839 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9840 if (dpyinfo
->font_table
[i
].name
== NULL
)
9843 /* If no free slot found, maybe enlarge the font table. */
9844 if (i
== dpyinfo
->n_fonts
9845 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
9848 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
9849 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
9851 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
9854 fontp
= dpyinfo
->font_table
+ i
;
9855 if (i
== dpyinfo
->n_fonts
)
9858 /* Now fill in the slots of *FONTP. */
9860 bzero (fontp
, sizeof (*fontp
));
9862 fontp
->font_idx
= i
;
9863 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
9864 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
9866 /* Try to get the full name of FONT. Put it in FULL_NAME. */
9868 if (XGetFontProperty (font
, XA_FONT
, &value
))
9870 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
9874 /* Count the number of dashes in the "full name".
9875 If it is too few, this isn't really the font's full name,
9877 In X11R4, the fonts did not come with their canonical names
9888 full_name
= (char *) xmalloc (p
- name
+ 1);
9889 bcopy (name
, full_name
, p
- name
+ 1);
9896 fontp
->full_name
= full_name
;
9898 fontp
->full_name
= fontp
->name
;
9900 fontp
->size
= font
->max_bounds
.width
;
9901 fontp
->height
= FONT_HEIGHT (font
);
9903 if (NILP (font_names
))
9905 /* We come here because of a bug of XListFonts mentioned at
9906 the head of this block. Let's store this information in
9907 the cache for x_list_fonts. */
9908 Lisp_Object lispy_name
= build_string (fontname
);
9909 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
9910 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
9913 XSETCDR (dpyinfo
->name_list_element
,
9915 Fcons (Fcons (lispy_full_name
,
9916 make_number (fontp
->size
)),
9918 XCDR (dpyinfo
->name_list_element
)));
9921 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
9923 XSETCDR (dpyinfo
->name_list_element
,
9925 Fcons (Fcons (lispy_full_name
,
9926 make_number (fontp
->size
)),
9928 XCDR (dpyinfo
->name_list_element
)));
9932 /* The slot `encoding' specifies how to map a character
9933 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
9934 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
9935 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
9936 2:0xA020..0xFF7F). For the moment, we don't know which charset
9937 uses this font. So, we set information in fontp->encoding[1]
9938 which is never used by any charset. If mapping can't be
9939 decided, set FONT_ENCODING_NOT_DECIDED. */
9941 = (font
->max_byte1
== 0
9943 ? (font
->min_char_or_byte2
< 0x80
9944 ? (font
->max_char_or_byte2
< 0x80
9945 ? 0 /* 0x20..0x7F */
9946 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
9947 : 1) /* 0xA0..0xFF */
9949 : (font
->min_byte1
< 0x80
9950 ? (font
->max_byte1
< 0x80
9951 ? (font
->min_char_or_byte2
< 0x80
9952 ? (font
->max_char_or_byte2
< 0x80
9953 ? 0 /* 0x2020..0x7F7F */
9954 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
9955 : 3) /* 0x20A0..0x7FFF */
9956 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
9957 : (font
->min_char_or_byte2
< 0x80
9958 ? (font
->max_char_or_byte2
< 0x80
9959 ? 2 /* 0xA020..0xFF7F */
9960 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
9961 : 1))); /* 0xA0A0..0xFFFF */
9963 fontp
->baseline_offset
9964 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
9965 ? (long) value
: 0);
9966 fontp
->relative_compose
9967 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
9968 ? (long) value
: 0);
9969 fontp
->default_ascent
9970 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
9971 ? (long) value
: 0);
9973 /* Set global flag fonts_changed_p to non-zero if the font loaded
9974 has a character with a smaller width than any other character
9975 before, or if the font loaded has a smaller height than any
9976 other font loaded before. If this happens, it will make a
9977 glyph matrix reallocation necessary. */
9978 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
9985 /* Return a pointer to struct font_info of a font named FONTNAME for
9986 frame F. If no such font is loaded, return NULL. */
9989 x_query_font (f
, fontname
)
9991 register char *fontname
;
9993 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9996 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9997 if (dpyinfo
->font_table
[i
].name
9998 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
9999 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
10000 return (dpyinfo
->font_table
+ i
);
10005 /* Find a CCL program for a font specified by FONTP, and set the member
10006 `encoder' of the structure. */
10009 x_find_ccl_program (fontp
)
10010 struct font_info
*fontp
;
10012 Lisp_Object list
, elt
;
10015 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
10019 && STRINGP (XCAR (elt
))
10020 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
10022 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
10029 struct ccl_program
*ccl
10030 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
10032 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
10035 fontp
->font_encoder
= ccl
;
10041 /***********************************************************************
10043 ***********************************************************************/
10045 #ifdef USE_X_TOOLKIT
10046 static XrmOptionDescRec emacs_options
[] = {
10047 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
10048 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
10050 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10051 XrmoptionSepArg
, NULL
},
10052 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
10054 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10055 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10056 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10057 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10058 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10059 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
10060 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
10062 #endif /* USE_X_TOOLKIT */
10064 static int x_initialized
;
10066 #ifdef MULTI_KBOARD
10067 /* Test whether two display-name strings agree up to the dot that separates
10068 the screen number from the server number. */
10070 same_x_server (name1
, name2
)
10071 const char *name1
, *name2
;
10073 int seen_colon
= 0;
10074 const unsigned char *system_name
= SDATA (Vsystem_name
);
10075 int system_name_length
= strlen (system_name
);
10076 int length_until_period
= 0;
10078 while (system_name
[length_until_period
] != 0
10079 && system_name
[length_until_period
] != '.')
10080 length_until_period
++;
10082 /* Treat `unix' like an empty host name. */
10083 if (! strncmp (name1
, "unix:", 5))
10085 if (! strncmp (name2
, "unix:", 5))
10087 /* Treat this host's name like an empty host name. */
10088 if (! strncmp (name1
, system_name
, system_name_length
)
10089 && name1
[system_name_length
] == ':')
10090 name1
+= system_name_length
;
10091 if (! strncmp (name2
, system_name
, system_name_length
)
10092 && name2
[system_name_length
] == ':')
10093 name2
+= system_name_length
;
10094 /* Treat this host's domainless name like an empty host name. */
10095 if (! strncmp (name1
, system_name
, length_until_period
)
10096 && name1
[length_until_period
] == ':')
10097 name1
+= length_until_period
;
10098 if (! strncmp (name2
, system_name
, length_until_period
)
10099 && name2
[length_until_period
] == ':')
10100 name2
+= length_until_period
;
10102 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
10106 if (seen_colon
&& *name1
== '.')
10110 && (*name1
== '.' || *name1
== '\0')
10111 && (*name2
== '.' || *name2
== '\0'));
10115 /* Count number of set bits in mask and number of bits to shift to
10116 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
10119 get_bits_and_offset (mask
, bits
, offset
)
10120 unsigned long mask
;
10127 while (!(mask
& 1))
10143 struct x_display_info
*
10144 x_term_init (display_name
, xrm_option
, resource_name
)
10145 Lisp_Object display_name
;
10147 char *resource_name
;
10151 struct x_display_info
*dpyinfo
;
10156 if (!x_initialized
)
10164 #define NUM_ARGV 10
10166 char *argv
[NUM_ARGV
];
10167 char **argv2
= argv
;
10170 if (x_initialized
++ > 1)
10172 /* Opening another display. If xg_display_open returns less
10173 than zero, we are probably on GTK 2.0, which can only handle
10174 one display. GTK 2.2 or later can handle more than one. */
10175 if (xg_display_open (SDATA (display_name
), &dpy
) < 0)
10176 error ("Sorry, this version of GTK can only handle one display");
10180 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
10184 argv
[argc
++] = initial_argv
[0];
10186 if (! NILP (display_name
))
10188 argv
[argc
++] = "--display";
10189 argv
[argc
++] = SDATA (display_name
);
10192 argv
[argc
++] = "--name";
10193 argv
[argc
++] = resource_name
;
10196 XSetLocaleModifiers ("");
10199 gtk_init (&argc
, &argv2
);
10201 /* gtk_init does set_locale. We must fix locale after calling it. */
10205 dpy
= GDK_DISPLAY ();
10207 /* NULL window -> events for all windows go to our function */
10208 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
10210 /* Load our own gtkrc if it exists. */
10212 struct gcpro gcpro1
, gcpro2
;
10213 char *file
= "~/.emacs.d/gtkrc";
10214 Lisp_Object s
, abs_file
;
10216 GCPRO2 (s
, abs_file
);
10217 s
= make_string (file
, strlen (file
));
10218 abs_file
= Fexpand_file_name (s
, Qnil
);
10220 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
10221 gtk_rc_parse (SDATA (abs_file
));
10226 XSetErrorHandler (x_error_handler
);
10227 XSetIOErrorHandler (x_io_error_quitter
);
10230 #else /* not USE_GTK */
10231 #ifdef USE_X_TOOLKIT
10232 /* weiner@footloose.sps.mot.com reports that this causes
10234 X protocol error: BadAtom (invalid Atom parameter)
10235 on protocol request 18skiloaf.
10236 So let's not use it until R6. */
10237 #ifdef HAVE_X11XTR6
10238 XtSetLanguageProc (NULL
, NULL
, NULL
);
10249 argv
[argc
++] = "-xrm";
10250 argv
[argc
++] = xrm_option
;
10252 turn_on_atimers (0);
10253 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
10254 resource_name
, EMACS_CLASS
,
10255 emacs_options
, XtNumber (emacs_options
),
10257 turn_on_atimers (1);
10259 #ifdef HAVE_X11XTR6
10260 /* I think this is to compensate for XtSetLanguageProc. */
10265 #else /* not USE_X_TOOLKIT */
10267 XSetLocaleModifiers ("");
10269 dpy
= XOpenDisplay (SDATA (display_name
));
10270 #endif /* not USE_X_TOOLKIT */
10271 #endif /* not USE_GTK*/
10273 /* Detect failure. */
10280 /* We have definitely succeeded. Record the new connection. */
10282 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
10283 bzero (dpyinfo
, sizeof *dpyinfo
);
10285 #ifdef MULTI_KBOARD
10287 struct x_display_info
*share
;
10290 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
10291 share
= share
->next
, tail
= XCDR (tail
))
10292 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
10293 SDATA (display_name
)))
10296 dpyinfo
->kboard
= share
->kboard
;
10299 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
10300 init_kboard (dpyinfo
->kboard
);
10301 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
10303 char *vendor
= ServerVendor (dpy
);
10305 dpyinfo
->kboard
->Vsystem_key_alist
10306 = call1 (Qvendor_specific_keysyms
,
10307 build_string (vendor
? vendor
: ""));
10311 dpyinfo
->kboard
->next_kboard
= all_kboards
;
10312 all_kboards
= dpyinfo
->kboard
;
10313 /* Don't let the initial kboard remain current longer than necessary.
10314 That would cause problems if a file loaded on startup tries to
10315 prompt in the mini-buffer. */
10316 if (current_kboard
== initial_kboard
)
10317 current_kboard
= dpyinfo
->kboard
;
10319 dpyinfo
->kboard
->reference_count
++;
10323 /* Put this display on the chain. */
10324 dpyinfo
->next
= x_display_list
;
10325 x_display_list
= dpyinfo
;
10327 /* Put it on x_display_name_list as well, to keep them parallel. */
10328 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
10329 x_display_name_list
);
10330 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
10332 dpyinfo
->display
= dpy
;
10335 XSetAfterFunction (x_current_display
, x_trace_wire
);
10339 = (char *) xmalloc (SBYTES (Vinvocation_name
)
10340 + SBYTES (Vsystem_name
)
10342 sprintf (dpyinfo
->x_id_name
, "%s@%s",
10343 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10345 /* Figure out which modifier bits mean what. */
10346 x_find_modifier_meanings (dpyinfo
);
10348 /* Get the scroll bar cursor. */
10350 /* We must create a GTK cursor, it is required for GTK widgets. */
10351 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10352 #endif /* USE_GTK */
10354 dpyinfo
->vertical_scroll_bar_cursor
10355 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10357 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10358 resource_name
, EMACS_CLASS
);
10359 #ifdef HAVE_XRMSETDATABASE
10360 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10362 dpyinfo
->display
->db
= xrdb
;
10364 /* Put the rdb where we can find it in a way that works on
10366 dpyinfo
->xrdb
= xrdb
;
10368 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10369 DefaultScreen (dpyinfo
->display
));
10370 select_visual (dpyinfo
);
10371 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10372 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
10373 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
10374 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10375 dpyinfo
->client_leader_window
= 0;
10376 dpyinfo
->grabbed
= 0;
10377 dpyinfo
->reference_count
= 0;
10378 dpyinfo
->icon_bitmap_id
= -1;
10379 dpyinfo
->font_table
= NULL
;
10380 dpyinfo
->n_fonts
= 0;
10381 dpyinfo
->font_table_size
= 0;
10382 dpyinfo
->bitmaps
= 0;
10383 dpyinfo
->bitmaps_size
= 0;
10384 dpyinfo
->bitmaps_last
= 0;
10385 dpyinfo
->scratch_cursor_gc
= 0;
10386 dpyinfo
->mouse_face_mouse_frame
= 0;
10387 dpyinfo
->mouse_face_deferred_gc
= 0;
10388 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10389 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10390 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10391 dpyinfo
->mouse_face_window
= Qnil
;
10392 dpyinfo
->mouse_face_overlay
= Qnil
;
10393 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10394 dpyinfo
->mouse_face_defer
= 0;
10395 dpyinfo
->mouse_face_hidden
= 0;
10396 dpyinfo
->x_focus_frame
= 0;
10397 dpyinfo
->x_focus_event_frame
= 0;
10398 dpyinfo
->x_highlight_frame
= 0;
10399 dpyinfo
->image_cache
= make_image_cache ();
10400 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10402 /* See if we can construct pixel values from RGB values. */
10403 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10404 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10406 if (dpyinfo
->visual
->class == TrueColor
)
10408 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10409 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10410 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10411 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10412 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10413 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10416 /* See if a private colormap is requested. */
10417 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10419 if (dpyinfo
->visual
->class == PseudoColor
)
10422 value
= display_x_get_resource (dpyinfo
,
10423 build_string ("privateColormap"),
10424 build_string ("PrivateColormap"),
10426 if (STRINGP (value
)
10427 && (!strcmp (SDATA (value
), "true")
10428 || !strcmp (SDATA (value
), "on")))
10429 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10433 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10434 dpyinfo
->visual
, AllocNone
);
10437 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10438 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10439 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10440 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10441 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10442 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10443 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10444 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10445 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10448 dpyinfo
->Xatom_wm_protocols
10449 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10450 dpyinfo
->Xatom_wm_take_focus
10451 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10452 dpyinfo
->Xatom_wm_save_yourself
10453 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10454 dpyinfo
->Xatom_wm_delete_window
10455 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10456 dpyinfo
->Xatom_wm_change_state
10457 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10458 dpyinfo
->Xatom_wm_configure_denied
10459 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10460 dpyinfo
->Xatom_wm_window_moved
10461 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10462 dpyinfo
->Xatom_wm_client_leader
10463 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10464 dpyinfo
->Xatom_editres
10465 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10466 dpyinfo
->Xatom_CLIPBOARD
10467 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10468 dpyinfo
->Xatom_TIMESTAMP
10469 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10470 dpyinfo
->Xatom_TEXT
10471 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10472 dpyinfo
->Xatom_COMPOUND_TEXT
10473 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10474 dpyinfo
->Xatom_UTF8_STRING
10475 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10476 dpyinfo
->Xatom_DELETE
10477 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10478 dpyinfo
->Xatom_MULTIPLE
10479 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10480 dpyinfo
->Xatom_INCR
10481 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10482 dpyinfo
->Xatom_EMACS_TMP
10483 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10484 dpyinfo
->Xatom_TARGETS
10485 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10486 dpyinfo
->Xatom_NULL
10487 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10488 dpyinfo
->Xatom_ATOM_PAIR
10489 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10490 /* For properties of font. */
10491 dpyinfo
->Xatom_PIXEL_SIZE
10492 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10493 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10494 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10495 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10496 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10497 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10498 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10500 /* Ghostscript support. */
10501 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10502 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10504 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10507 dpyinfo
->cut_buffers_initialized
= 0;
10509 connection
= ConnectionNumber (dpyinfo
->display
);
10510 dpyinfo
->connection
= connection
;
10515 null_bits
[0] = 0x00;
10517 dpyinfo
->null_pixel
10518 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10519 null_bits
, 1, 1, (long) 0, (long) 0,
10524 extern int gray_bitmap_width
, gray_bitmap_height
;
10525 extern char *gray_bitmap_bits
;
10527 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10529 gray_bitmap_width
, gray_bitmap_height
,
10530 (unsigned long) 1, (unsigned long) 0, 1);
10534 xim_initialize (dpyinfo
, resource_name
);
10537 #ifdef subprocesses
10538 /* This is only needed for distinguishing keyboard and process input. */
10539 if (connection
!= 0)
10540 add_keyboard_wait_descriptor (connection
);
10543 #ifndef F_SETOWN_BUG
10545 #ifdef F_SETOWN_SOCK_NEG
10546 /* stdin is a socket here */
10547 fcntl (connection
, F_SETOWN
, -getpid ());
10548 #else /* ! defined (F_SETOWN_SOCK_NEG) */
10549 fcntl (connection
, F_SETOWN
, getpid ());
10550 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
10551 #endif /* ! defined (F_SETOWN) */
10552 #endif /* F_SETOWN_BUG */
10555 if (interrupt_input
)
10556 init_sigio (connection
);
10557 #endif /* ! defined (SIGIO) */
10560 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
10561 /* Make sure that we have a valid font for dialog boxes
10562 so that Xt does not crash. */
10564 Display
*dpy
= dpyinfo
->display
;
10565 XrmValue d
, fr
, to
;
10569 d
.addr
= (XPointer
)&dpy
;
10570 d
.size
= sizeof (Display
*);
10571 fr
.addr
= XtDefaultFont
;
10572 fr
.size
= sizeof (XtDefaultFont
);
10573 to
.size
= sizeof (Font
*);
10574 to
.addr
= (XPointer
)&font
;
10575 count
= x_catch_errors (dpy
);
10576 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10578 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10579 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10580 x_uncatch_errors (dpy
, count
);
10585 /* See if we should run in synchronous mode. This is useful
10586 for debugging X code. */
10589 value
= display_x_get_resource (dpyinfo
,
10590 build_string ("synchronous"),
10591 build_string ("Synchronous"),
10593 if (STRINGP (value
)
10594 && (!strcmp (SDATA (value
), "true")
10595 || !strcmp (SDATA (value
), "on")))
10596 XSynchronize (dpyinfo
->display
, True
);
10601 value
= display_x_get_resource (dpyinfo
,
10602 build_string ("useXIM"),
10603 build_string ("UseXIM"),
10606 if (STRINGP (value
)
10607 && (!strcmp (XSTRING (value
)->data
, "false")
10608 || !strcmp (XSTRING (value
)->data
, "off")))
10611 if (STRINGP (value
)
10612 && (!strcmp (XSTRING (value
)->data
, "true")
10613 || !strcmp (XSTRING (value
)->data
, "on")))
10619 /* Only do this for the first display. */
10620 if (x_initialized
== 1)
10621 x_session_initialize (dpyinfo
);
10629 /* Get rid of display DPYINFO, assuming all frames are already gone,
10630 and without sending any more commands to the X server. */
10633 x_delete_display (dpyinfo
)
10634 struct x_display_info
*dpyinfo
;
10638 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10640 /* Discard this display from x_display_name_list and x_display_list.
10641 We can't use Fdelq because that can quit. */
10642 if (! NILP (x_display_name_list
)
10643 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10644 x_display_name_list
= XCDR (x_display_name_list
);
10649 tail
= x_display_name_list
;
10650 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10652 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10654 XSETCDR (tail
, XCDR (XCDR (tail
)));
10657 tail
= XCDR (tail
);
10661 if (next_noop_dpyinfo
== dpyinfo
)
10662 next_noop_dpyinfo
= dpyinfo
->next
;
10664 if (x_display_list
== dpyinfo
)
10665 x_display_list
= dpyinfo
->next
;
10668 struct x_display_info
*tail
;
10670 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10671 if (tail
->next
== dpyinfo
)
10672 tail
->next
= tail
->next
->next
;
10675 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
10676 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
10677 XrmDestroyDatabase (dpyinfo
->xrdb
);
10680 #ifdef MULTI_KBOARD
10681 if (--dpyinfo
->kboard
->reference_count
== 0)
10682 delete_kboard (dpyinfo
->kboard
);
10686 xim_close_dpy (dpyinfo
);
10689 /* Free the font names in the font table. */
10690 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10691 if (dpyinfo
->font_table
[i
].name
)
10693 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
10694 xfree (dpyinfo
->font_table
[i
].full_name
);
10695 xfree (dpyinfo
->font_table
[i
].name
);
10698 if (dpyinfo
->font_table
->font_encoder
)
10699 xfree (dpyinfo
->font_table
->font_encoder
);
10701 xfree (dpyinfo
->font_table
);
10702 xfree (dpyinfo
->x_id_name
);
10703 xfree (dpyinfo
->color_cells
);
10707 #ifdef USE_X_TOOLKIT
10709 /* Atimer callback function for TIMER. Called every 0.1s to process
10710 Xt timeouts, if needed. We must avoid calling XtAppPending as
10711 much as possible because that function does an implicit XFlush
10712 that slows us down. */
10715 x_process_timeouts (timer
)
10716 struct atimer
*timer
;
10718 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10721 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10722 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10727 #endif /* USE_X_TOOLKIT */
10730 /* Set up use of X before we make the first connection. */
10732 extern frame_parm_handler x_frame_parm_handlers
[];
10734 static struct redisplay_interface x_redisplay_interface
=
10736 x_frame_parm_handlers
,
10740 x_clear_end_of_line
,
10742 x_after_update_window_line
,
10743 x_update_window_begin
,
10744 x_update_window_end
,
10750 0, /* flush_display_optional */
10752 x_clear_window_mouse_face
,
10753 x_get_glyph_overhangs
,
10754 x_fix_overlapping_area
,
10755 x_draw_fringe_bitmap
,
10756 0, /* define_fringe_bitmap */
10757 0, /* destroy_fringe_bitmap */
10760 x_compute_glyph_string_overhangs
,
10761 x_draw_glyph_string
,
10762 x_define_frame_cursor
,
10763 x_clear_frame_area
,
10764 x_draw_window_cursor
,
10765 x_draw_vertical_window_border
,
10766 x_shift_glyphs_for_insert
10772 rif
= &x_redisplay_interface
;
10774 clear_frame_hook
= x_clear_frame
;
10775 ins_del_lines_hook
= x_ins_del_lines
;
10776 delete_glyphs_hook
= x_delete_glyphs
;
10777 ring_bell_hook
= XTring_bell
;
10778 reset_terminal_modes_hook
= XTreset_terminal_modes
;
10779 set_terminal_modes_hook
= XTset_terminal_modes
;
10780 update_begin_hook
= x_update_begin
;
10781 update_end_hook
= x_update_end
;
10782 set_terminal_window_hook
= XTset_terminal_window
;
10783 read_socket_hook
= XTread_socket
;
10784 frame_up_to_date_hook
= XTframe_up_to_date
;
10785 mouse_position_hook
= XTmouse_position
;
10786 frame_rehighlight_hook
= XTframe_rehighlight
;
10787 frame_raise_lower_hook
= XTframe_raise_lower
;
10788 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10789 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10790 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10791 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10793 scroll_region_ok
= 1; /* we'll scroll partial frames */
10794 char_ins_del_ok
= 1;
10795 line_ins_del_ok
= 1; /* we'll just blt 'em */
10796 fast_clear_end_of_line
= 1; /* X does this well */
10797 memory_below_frame
= 0; /* we don't remember what scrolls
10802 last_tool_bar_item
= -1;
10803 any_help_event_p
= 0;
10804 ignore_next_mouse_click_timeout
= 0;
10807 current_count
= -1;
10810 /* Try to use interrupt input; if we can't, then start polling. */
10811 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
10813 #ifdef USE_X_TOOLKIT
10814 XtToolkitInitialize ();
10816 Xt_app_con
= XtCreateApplicationContext ();
10818 /* Register a converter from strings to pixels, which uses
10819 Emacs' color allocation infrastructure. */
10820 XtAppSetTypeConverter (Xt_app_con
,
10821 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10822 cvt_string_to_pixel_args
,
10823 XtNumber (cvt_string_to_pixel_args
),
10824 XtCacheByDisplay
, cvt_pixel_dtor
);
10826 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10828 /* Install an asynchronous timer that processes Xt timeout events
10829 every 0.1s. This is necessary because some widget sets use
10830 timeouts internally, for example the LessTif menu bar, or the
10831 Xaw3d scroll bar. When Xt timouts aren't processed, these
10832 widgets don't behave normally. */
10834 EMACS_TIME interval
;
10835 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10836 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
10840 #ifdef USE_TOOLKIT_SCROLL_BARS
10842 xaw3d_arrow_scroll
= False
;
10843 xaw3d_pick_top
= True
;
10847 /* Note that there is no real way portable across R3/R4 to get the
10848 original error handler. */
10849 XSetErrorHandler (x_error_handler
);
10850 XSetIOErrorHandler (x_io_error_quitter
);
10852 /* Disable Window Change signals; they are handled by X events. */
10854 signal (SIGWINCH
, SIG_DFL
);
10855 #endif /* SIGWINCH */
10857 signal (SIGPIPE
, x_connection_signal
);
10864 staticpro (&x_error_message_string
);
10865 x_error_message_string
= Qnil
;
10867 staticpro (&x_display_name_list
);
10868 x_display_name_list
= Qnil
;
10870 staticpro (&last_mouse_scroll_bar
);
10871 last_mouse_scroll_bar
= Qnil
;
10873 staticpro (&Qvendor_specific_keysyms
);
10874 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
10876 staticpro (&Qutf_8
);
10877 Qutf_8
= intern ("utf-8");
10878 staticpro (&Qlatin_1
);
10879 Qlatin_1
= intern ("latin-1");
10881 staticpro (&last_mouse_press_frame
);
10882 last_mouse_press_frame
= Qnil
;
10884 DEFVAR_BOOL ("x-use-underline-position-properties",
10885 &x_use_underline_position_properties
,
10886 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10887 nil means ignore them. If you encounter fonts with bogus
10888 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10889 to 4.1, set this to nil. */);
10890 x_use_underline_position_properties
= 1;
10892 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10893 &x_mouse_click_focus_ignore_position
,
10894 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10895 This variable is only used when the window manager requires that you
10896 click on a frame to select it (give it focus). In that case, a value
10897 of nil, means that the selected window and cursor position changes to
10898 reflect the mouse click position, while a non-nil value means that the
10899 selected window or cursor position is preserved. */);
10900 x_mouse_click_focus_ignore_position
= 0;
10902 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10903 doc
: /* What X toolkit scroll bars Emacs uses.
10904 A value of nil means Emacs doesn't use X toolkit scroll bars.
10905 Otherwise, value is a symbol describing the X toolkit. */);
10906 #ifdef USE_TOOLKIT_SCROLL_BARS
10908 Vx_toolkit_scroll_bars
= intern ("motif");
10909 #elif defined HAVE_XAW3D
10910 Vx_toolkit_scroll_bars
= intern ("xaw3d");
10912 Vx_toolkit_scroll_bars
= intern ("gtk");
10914 Vx_toolkit_scroll_bars
= intern ("xaw");
10917 Vx_toolkit_scroll_bars
= Qnil
;
10920 staticpro (&last_mouse_motion_frame
);
10921 last_mouse_motion_frame
= Qnil
;
10923 Qmodifier_value
= intern ("modifier-value");
10924 Qalt
= intern ("alt");
10925 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10926 Qhyper
= intern ("hyper");
10927 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10928 Qmeta
= intern ("meta");
10929 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10930 Qsuper
= intern ("super");
10931 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10933 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
10934 doc
: /* Which keys Emacs uses for the alt modifier.
10935 This should be one of the symbols `alt', `hyper', `meta', `super'.
10936 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10937 is nil, which is the same as `alt'. */);
10938 Vx_alt_keysym
= Qnil
;
10940 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
10941 doc
: /* Which keys Emacs uses for the hyper modifier.
10942 This should be one of the symbols `alt', `hyper', `meta', `super'.
10943 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10944 default is nil, which is the same as `hyper'. */);
10945 Vx_hyper_keysym
= Qnil
;
10947 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
10948 doc
: /* Which keys Emacs uses for the meta modifier.
10949 This should be one of the symbols `alt', `hyper', `meta', `super'.
10950 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10951 default is nil, which is the same as `meta'. */);
10952 Vx_meta_keysym
= Qnil
;
10954 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
10955 doc
: /* Which keys Emacs uses for the super modifier.
10956 This should be one of the symbols `alt', `hyper', `meta', `super'.
10957 For example, `super' means use the Super_L and Super_R keysyms. The
10958 default is nil, which is the same as `super'. */);
10959 Vx_super_keysym
= Qnil
;
10961 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
10962 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10963 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
10964 make_float (DEFAULT_REHASH_SIZE
),
10965 make_float (DEFAULT_REHASH_THRESHOLD
),
10969 #endif /* HAVE_X_WINDOWS */
10971 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
10972 (do not change this comment) */