1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000, 2001, 2002
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
101 extern int xlwmenu_window_p (Widget w
, Window window
);
102 extern void xlwmenu_redisplay
P_ ((Widget
));
107 extern void free_frame_menubar
P_ ((struct frame
*));
108 extern struct frame
*x_menubar_window_to_frame
P_ ((struct x_display_info
*,
111 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
113 extern void _XEditResCheckMessages ();
114 #endif /* not NO_EDITRES */
116 /* Include toolkit specific headers for the scroll bar widget. */
118 #ifdef USE_TOOLKIT_SCROLL_BARS
119 #if defined USE_MOTIF
120 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
121 #include <Xm/ScrollBar.h>
122 #else /* !USE_MOTIF i.e. use Xaw */
125 #include <X11/Xaw3d/Simple.h>
126 #include <X11/Xaw3d/Scrollbar.h>
127 #define ARROW_SCROLLBAR
128 #include <X11/Xaw3d/ScrollbarP.h>
129 #else /* !HAVE_XAW3D */
130 #include <X11/Xaw/Simple.h>
131 #include <X11/Xaw/Scrollbar.h>
132 #endif /* !HAVE_XAW3D */
134 #define XtNpickTop "pickTop"
135 #endif /* !XtNpickTop */
136 #endif /* !USE_MOTIF */
137 #endif /* USE_TOOLKIT_SCROLL_BARS */
139 #endif /* USE_X_TOOLKIT */
141 #ifndef USE_X_TOOLKIT
142 #define x_any_window_to_frame x_window_to_frame
143 #define x_top_window_to_frame x_window_to_frame
148 #ifndef XtNinitialState
149 #define XtNinitialState "initialState"
153 #define abs(x) ((x) < 0 ? -(x) : (x))
155 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
158 /* Fringe bitmaps. */
160 enum fringe_bitmap_type
163 LEFT_TRUNCATION_BITMAP
,
164 RIGHT_TRUNCATION_BITMAP
,
165 OVERLAY_ARROW_BITMAP
,
166 CONTINUED_LINE_BITMAP
,
167 CONTINUATION_LINE_BITMAP
,
171 /* Bitmap drawn to indicate lines not displaying text if
172 `indicate-empty-lines' is non-nil. */
177 static unsigned char zv_bits
[] = {
178 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
179 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
180 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
181 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
182 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
183 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
184 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
185 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
187 /* An arrow like this: `<-'. */
190 #define left_height 8
191 static unsigned char left_bits
[] = {
192 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
194 /* Right truncation arrow bitmap `->'. */
196 #define right_width 8
197 #define right_height 8
198 static unsigned char right_bits
[] = {
199 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
201 /* Marker for continued lines. */
203 #define continued_width 8
204 #define continued_height 8
205 static unsigned char continued_bits
[] = {
206 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
208 /* Marker for continuation lines. */
210 #define continuation_width 8
211 #define continuation_height 8
212 static unsigned char continuation_bits
[] = {
213 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
215 /* Overlay arrow bitmap. */
221 static unsigned char ov_bits
[] = {
222 0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
224 /* A triangular arrow. */
227 static unsigned char ov_bits
[] = {
228 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
232 extern Lisp_Object Qhelp_echo
;
235 /* Non-nil means Emacs uses toolkit scroll bars. */
237 Lisp_Object Vx_toolkit_scroll_bars
;
239 /* If a string, XTread_socket generates an event to display that string.
240 (The display is done in read_char.) */
242 static Lisp_Object help_echo
;
243 static Lisp_Object help_echo_window
;
244 static Lisp_Object help_echo_object
;
245 static int help_echo_pos
;
247 /* Temporary variable for XTread_socket. */
249 static Lisp_Object previous_help_echo
;
251 /* Non-zero means that a HELP_EVENT has been generated since Emacs
254 static int any_help_event_p
;
256 /* Non-zero means autoselect window with the mouse cursor. */
258 int mouse_autoselect_window
;
260 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
261 static Lisp_Object last_window
;
263 /* Non-zero means draw block and hollow cursor as wide as the glyph
264 under it. For example, if a block cursor is over a tab, it will be
265 drawn as wide as that tab on the display. */
267 int x_stretch_cursor_p
;
269 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
271 int x_use_underline_position_properties
;
273 /* This is a chain of structures for all the X displays currently in
276 struct x_display_info
*x_display_list
;
278 /* This is a list of cons cells, each of the form (NAME
279 . FONT-LIST-CACHE), one for each element of x_display_list and in
280 the same order. NAME is the name of the frame. FONT-LIST-CACHE
281 records previous values returned by x-list-fonts. */
283 Lisp_Object x_display_name_list
;
285 /* Frame being updated by update_frame. This is declared in term.c.
286 This is set by update_begin and looked at by all the XT functions.
287 It is zero while not inside an update. In that case, the XT
288 functions assume that `selected_frame' is the frame to apply to. */
290 extern struct frame
*updating_frame
;
292 /* This is a frame waiting to be auto-raised, within XTread_socket. */
294 struct frame
*pending_autoraise_frame
;
297 /* The application context for Xt use. */
298 XtAppContext Xt_app_con
;
299 static String Xt_default_resources
[] = {0};
300 #endif /* USE_X_TOOLKIT */
302 /* Nominal cursor position -- where to draw output.
303 HPOS and VPOS are window relative glyph matrix coordinates.
304 X and Y are window relative pixel coordinates. */
306 struct cursor_pos output_cursor
;
308 /* Non-zero means user is interacting with a toolkit scroll bar. */
310 static int toolkit_scroll_bar_interaction
;
314 Formerly, we used PointerMotionHintMask (in standard_event_mask)
315 so that we would have to call XQueryPointer after each MotionNotify
316 event to ask for another such event. However, this made mouse tracking
317 slow, and there was a bug that made it eventually stop.
319 Simply asking for MotionNotify all the time seems to work better.
321 In order to avoid asking for motion events and then throwing most
322 of them away or busy-polling the server for mouse positions, we ask
323 the server for pointer motion hints. This means that we get only
324 one event per group of mouse movements. "Groups" are delimited by
325 other kinds of events (focus changes and button clicks, for
326 example), or by XQueryPointer calls; when one of these happens, we
327 get another MotionNotify event the next time the mouse moves. This
328 is at least as efficient as getting motion events when mouse
329 tracking is on, and I suspect only negligibly worse when tracking
332 /* Where the mouse was last time we reported a mouse event. */
334 FRAME_PTR last_mouse_frame
;
335 static XRectangle last_mouse_glyph
;
336 static Lisp_Object last_mouse_press_frame
;
338 /* The scroll bar in which the last X motion event occurred.
340 If the last X motion event occurred in a scroll bar, we set this so
341 XTmouse_position can know whether to report a scroll bar motion or
344 If the last X motion event didn't occur in a scroll bar, we set
345 this to Qnil, to tell XTmouse_position to return an ordinary motion
348 static Lisp_Object last_mouse_scroll_bar
;
350 /* This is a hack. We would really prefer that XTmouse_position would
351 return the time associated with the position it returns, but there
352 doesn't seem to be any way to wrest the time-stamp from the server
353 along with the position query. So, we just keep track of the time
354 of the last movement we received, and return that in hopes that
355 it's somewhat accurate. */
357 static Time last_mouse_movement_time
;
359 /* Incremented by XTread_socket whenever it really tries to read
363 static int volatile input_signal_count
;
365 static int input_signal_count
;
368 /* Used locally within XTread_socket. */
370 static int x_noop_count
;
372 /* Initial values of argv and argc. */
374 extern char **initial_argv
;
375 extern int initial_argc
;
377 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
379 /* Tells if a window manager is present or not. */
381 extern Lisp_Object Vx_no_window_manager
;
383 extern Lisp_Object Qface
, Qmouse_face
;
387 /* A mask of extra modifier bits to put into every keyboard char. */
389 extern EMACS_INT extra_keyboard_modifiers
;
391 /* The keysyms to use for the various modifiers. */
393 Lisp_Object Vx_alt_keysym
, Vx_hyper_keysym
, Vx_meta_keysym
, Vx_super_keysym
;
394 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
396 static Lisp_Object Qvendor_specific_keysyms
;
397 static Lisp_Object Qlatin_1
, Qutf_8
;
399 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
400 extern Lisp_Object x_icon_type
P_ ((struct frame
*));
403 /* Enumeration for overriding/changing the face to use for drawing
404 glyphs in x_draw_glyphs. */
406 enum draw_glyphs_face
416 static int cursor_in_mouse_face_p
P_ ((struct window
*));
417 static int clear_mouse_face
P_ ((struct x_display_info
*));
418 static int x_alloc_nearest_color_1
P_ ((Display
*, Colormap
, XColor
*));
419 static void x_set_window_size_1
P_ ((struct frame
*, int, int, int));
420 static const XColor
*x_color_cells
P_ ((Display
*, int *));
421 static void x_update_window_end
P_ ((struct window
*, int, int));
422 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
423 void x_delete_display
P_ ((struct x_display_info
*));
424 static unsigned int x_x_to_emacs_modifiers
P_ ((struct x_display_info
*,
426 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
427 int *, int *, Lisp_Object
));
428 static int fast_find_string_pos
P_ ((struct window
*, int, Lisp_Object
,
429 int *, int *, int *, int *, int));
430 static void set_output_cursor
P_ ((struct cursor_pos
*));
431 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
432 int *, int *, int *, int));
433 static void note_mode_line_or_margin_highlight
P_ ((struct window
*, int,
435 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
436 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
437 static void x_handle_tool_bar_click
P_ ((struct frame
*, XButtonEvent
*));
438 static void show_mouse_face
P_ ((struct x_display_info
*,
439 enum draw_glyphs_face
));
440 static int x_io_error_quitter
P_ ((Display
*));
441 int x_catch_errors
P_ ((Display
*));
442 void x_uncatch_errors
P_ ((Display
*, int));
443 void x_lower_frame
P_ ((struct frame
*));
444 void x_scroll_bar_clear
P_ ((struct frame
*));
445 int x_had_errors_p
P_ ((Display
*));
446 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
447 void x_raise_frame
P_ ((struct frame
*));
448 void x_set_window_size
P_ ((struct frame
*, int, int, int));
449 void x_wm_set_window_state
P_ ((struct frame
*, int));
450 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
451 void x_initialize
P_ ((void));
452 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
453 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
454 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
456 enum draw_glyphs_face
));
457 static void x_update_end
P_ ((struct frame
*));
458 static void XTframe_up_to_date
P_ ((struct frame
*));
459 static void XTset_terminal_modes
P_ ((void));
460 static void XTreset_terminal_modes
P_ ((void));
461 static void XTcursor_to
P_ ((int, int, int, int));
462 static void x_write_glyphs
P_ ((struct glyph
*, int));
463 static void x_clear_end_of_line
P_ ((int));
464 static void x_clear_frame
P_ ((void));
465 static void x_clear_cursor
P_ ((struct window
*));
466 static void frame_highlight
P_ ((struct frame
*));
467 static void frame_unhighlight
P_ ((struct frame
*));
468 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
469 static void XTframe_rehighlight
P_ ((struct frame
*));
470 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
471 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
472 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
473 enum text_cursor_kinds
));
474 static int x_intersect_rectangles
P_ ((XRectangle
*, XRectangle
*,
476 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
477 static int expose_window_tree
P_ ((struct window
*, XRectangle
*));
478 static int expose_window
P_ ((struct window
*, XRectangle
*));
479 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
480 XRectangle
*, enum glyph_row_area
));
481 static int expose_line
P_ ((struct window
*, struct glyph_row
*,
483 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
484 static void x_update_window_cursor
P_ ((struct window
*, int));
485 static void x_erase_phys_cursor
P_ ((struct window
*));
486 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
487 static void x_draw_fringe_bitmap
P_ ((struct window
*, struct glyph_row
*,
488 enum fringe_bitmap_type
, int left_p
));
490 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
492 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, XRectangle
*));
493 static void x_draw_row_fringe_bitmaps
P_ ((struct window
*, struct glyph_row
*));
494 static void notice_overwritten_cursor
P_ ((struct window
*, enum glyph_row_area
,
495 int, int, int, int));
496 static void x_flush
P_ ((struct frame
*f
));
497 static void x_update_begin
P_ ((struct frame
*));
498 static void x_update_window_begin
P_ ((struct window
*));
499 static void x_draw_vertical_border
P_ ((struct window
*));
500 static void x_after_update_window_line
P_ ((struct glyph_row
*));
501 static INLINE
void take_vertical_position_into_account
P_ ((struct it
*));
502 static void x_produce_stretch_glyph
P_ ((struct it
*));
503 static struct scroll_bar
*x_window_to_scroll_bar
P_ ((Window
));
504 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
505 enum scroll_bar_part
*,
506 Lisp_Object
*, Lisp_Object
*,
508 static void x_check_fullscreen
P_ ((struct frame
*));
509 static void x_check_fullscreen_move
P_ ((struct frame
*));
511 /* Flush display of frame F, or of all frames if F is null. */
520 Lisp_Object rest
, frame
;
521 FOR_EACH_FRAME (rest
, frame
)
522 x_flush (XFRAME (frame
));
524 else if (FRAME_X_P (f
))
525 XFlush (FRAME_X_DISPLAY (f
));
530 /* Remove calls to XFlush by defining XFlush to an empty replacement.
531 Calls to XFlush should be unnecessary because the X output buffer
532 is flushed automatically as needed by calls to XPending,
533 XNextEvent, or XWindowEvent according to the XFlush man page.
534 XTread_socket calls XPending. Removing XFlush improves
537 #define XFlush(DISPLAY) (void) 0
540 /***********************************************************************
542 ***********************************************************************/
546 /* This is a function useful for recording debugging information about
547 the sequence of occurrences in this file. */
555 struct record event_record
[100];
557 int event_record_index
;
559 record_event (locus
, type
)
563 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
564 event_record_index
= 0;
566 event_record
[event_record_index
].locus
= locus
;
567 event_record
[event_record_index
].type
= type
;
568 event_record_index
++;
575 /* Return the struct x_display_info corresponding to DPY. */
577 struct x_display_info
*
578 x_display_info_for_display (dpy
)
581 struct x_display_info
*dpyinfo
;
583 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
584 if (dpyinfo
->display
== dpy
)
592 /***********************************************************************
593 Starting and ending an update
594 ***********************************************************************/
596 /* Start an update of frame F. This function is installed as a hook
597 for update_begin, i.e. it is called when update_begin is called.
598 This function is called prior to calls to x_update_window_begin for
599 each window being updated. Currently, there is nothing to do here
600 because all interesting stuff is done on a window basis. */
610 /* Start update of window W. Set the global variable updated_window
611 to the window being updated and set output_cursor to the cursor
615 x_update_window_begin (w
)
618 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
619 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
622 set_output_cursor (&w
->cursor
);
626 if (f
== display_info
->mouse_face_mouse_frame
)
628 /* Don't do highlighting for mouse motion during the update. */
629 display_info
->mouse_face_defer
= 1;
631 /* If F needs to be redrawn, simply forget about any prior mouse
633 if (FRAME_GARBAGED_P (f
))
634 display_info
->mouse_face_window
= Qnil
;
636 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
637 their mouse_face_p flag set, which means that they are always
638 unequal to rows in a desired matrix which never have that
639 flag set. So, rows containing mouse-face glyphs are never
640 scrolled, and we don't have to switch the mouse highlight off
641 here to prevent it from being scrolled. */
643 /* Can we tell that this update does not affect the window
644 where the mouse highlight is? If so, no need to turn off.
645 Likewise, don't do anything if the frame is garbaged;
646 in that case, the frame's current matrix that we would use
647 is all wrong, and we will redisplay that line anyway. */
648 if (!NILP (display_info
->mouse_face_window
)
649 && w
== XWINDOW (display_info
->mouse_face_window
))
653 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
654 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
657 if (i
< w
->desired_matrix
->nrows
)
658 clear_mouse_face (display_info
);
667 /* Draw a vertical window border to the right of window W if W doesn't
668 have vertical scroll bars. */
671 x_draw_vertical_border (w
)
674 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
676 /* Redraw borders between horizontally adjacent windows. Don't
677 do it for frames with vertical scroll bars because either the
678 right scroll bar of a window, or the left scroll bar of its
679 neighbor will suffice as a border. */
680 if (!WINDOW_RIGHTMOST_P (w
)
681 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
685 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
686 x1
+= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
689 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
690 f
->output_data
.x
->normal_gc
, x1
, y0
, x1
, y1
);
695 /* End update of window W (which is equal to updated_window).
697 Draw vertical borders between horizontally adjacent windows, and
698 display W's cursor if CURSOR_ON_P is non-zero.
700 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
701 glyphs in mouse-face were overwritten. In that case we have to
702 make sure that the mouse-highlight is properly redrawn.
704 W may be a menu bar pseudo-window in case we don't have X toolkit
705 support. Such windows don't have a cursor, so don't display it
709 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
711 int cursor_on_p
, mouse_face_overwritten_p
;
713 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
715 if (!w
->pseudo_window_p
)
720 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
722 output_cursor
.x
, output_cursor
.y
);
724 x_draw_vertical_border (w
);
728 /* If a row with mouse-face was overwritten, arrange for
729 XTframe_up_to_date to redisplay the mouse highlight. */
730 if (mouse_face_overwritten_p
)
732 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
733 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
734 dpyinfo
->mouse_face_window
= Qnil
;
737 updated_window
= NULL
;
741 /* End update of frame F. This function is installed as a hook in
748 /* Mouse highlight may be displayed again. */
749 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
752 XFlush (FRAME_X_DISPLAY (f
));
757 /* This function is called from various places in xdisp.c whenever a
758 complete update has been performed. The global variable
759 updated_window is not available here. */
762 XTframe_up_to_date (f
)
767 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
769 if (dpyinfo
->mouse_face_deferred_gc
770 || f
== dpyinfo
->mouse_face_mouse_frame
)
773 if (dpyinfo
->mouse_face_mouse_frame
)
774 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
775 dpyinfo
->mouse_face_mouse_x
,
776 dpyinfo
->mouse_face_mouse_y
);
777 dpyinfo
->mouse_face_deferred_gc
= 0;
784 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
785 arrow bitmaps, or clear the fringes if no bitmaps are required
786 before DESIRED_ROW is made current. The window being updated is
787 found in updated_window. This function It is called from
788 update_window_line only if it is known that there are differences
789 between bitmaps to be drawn between current row and DESIRED_ROW. */
792 x_after_update_window_line (desired_row
)
793 struct glyph_row
*desired_row
;
795 struct window
*w
= updated_window
;
801 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
804 x_draw_row_fringe_bitmaps (w
, desired_row
);
808 /* When a window has disappeared, make sure that no rest of
809 full-width rows stays visible in the internal border. Could
810 check here if updated_window is the leftmost/rightmost window,
811 but I guess it's not worth doing since vertically split windows
812 are almost never used, internal border is rarely set, and the
813 overhead is very small. */
814 if (windows_or_buffers_changed
815 && desired_row
->full_width_p
816 && (f
= XFRAME (w
->frame
),
817 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
819 && (height
= desired_row
->visible_height
,
822 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
824 /* Internal border is drawn below the tool bar. */
825 if (WINDOWP (f
->tool_bar_window
)
826 && w
== XWINDOW (f
->tool_bar_window
))
830 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
831 0, y
, width
, height
, False
);
832 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
833 f
->output_data
.x
->pixel_width
- width
,
834 y
, width
, height
, False
);
840 /* Draw the bitmap WHICH in one of the left or right fringes of
841 window W. ROW is the glyph row for which to display the bitmap; it
842 determines the vertical position at which the bitmap has to be
846 x_draw_fringe_bitmap (w
, row
, which
, left_p
)
848 struct glyph_row
*row
;
849 enum fringe_bitmap_type which
;
852 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
853 Display
*display
= FRAME_X_DISPLAY (f
);
854 Window window
= FRAME_X_WINDOW (f
);
857 unsigned char *bits
= NULL
;
859 GC gc
= f
->output_data
.x
->normal_gc
;
861 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
863 /* Must clip because of partially visible lines. */
864 x_clip_to_row (w
, row
, gc
, 1);
866 /* Convert row to frame coordinates. */
867 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
871 case NO_FRINGE_BITMAP
:
876 case LEFT_TRUNCATION_BITMAP
:
882 case OVERLAY_ARROW_BITMAP
:
888 case RIGHT_TRUNCATION_BITMAP
:
894 case CONTINUED_LINE_BITMAP
:
895 wd
= continued_width
;
896 h
= continued_height
;
897 bits
= continued_bits
;
900 case CONTINUATION_LINE_BITMAP
:
901 wd
= continuation_width
;
902 h
= continuation_height
;
903 bits
= continuation_bits
;
908 h
= zv_height
- (y
% zv_period
);
909 bits
= zv_bits
+ (y
% zv_period
);
916 /* Clip bitmap if too high. */
920 /* Set dy to the offset in the row to start drawing the bitmap. */
921 dy
= (row
->height
- h
) / 2;
923 face
= FACE_FROM_ID (f
, FRINGE_FACE_ID
);
924 PREPARE_FACE_FOR_DISPLAY (f
, face
);
926 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
931 if (wd
> FRAME_X_LEFT_FRINGE_WIDTH (f
))
932 wd
= FRAME_X_LEFT_FRINGE_WIDTH (f
);
933 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
935 - (FRAME_X_LEFT_FRINGE_WIDTH (f
) - wd
) / 2);
936 if (wd
< FRAME_X_LEFT_FRINGE_WIDTH (f
) || row
->height
> h
)
938 /* If W has a vertical border to its left, don't draw over it. */
939 int border
= ((XFASTINT (w
->left
) > 0
940 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
942 b1
= (window_box_left (w
, -1)
943 - FRAME_X_LEFT_FRINGE_WIDTH (f
)
945 b2
= (FRAME_X_LEFT_FRINGE_WIDTH (f
) - border
);
950 if (wd
> FRAME_X_RIGHT_FRINGE_WIDTH (f
))
951 wd
= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
952 x
= (window_box_right (w
, -1)
953 + (FRAME_X_RIGHT_FRINGE_WIDTH (f
) - wd
) / 2);
954 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
956 if (wd
< FRAME_X_RIGHT_FRINGE_WIDTH (f
) || row
->height
> h
)
958 b1
= window_box_right (w
, -1);
959 b2
= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
965 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
967 /* In case the same realized face is used for fringes and
968 for something displayed in the text (e.g. face `region' on
969 mono-displays, the fill style may have been changed to
970 FillSolid in x_draw_glyph_string_background. */
972 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
974 XSetForeground (display
, face
->gc
, face
->background
);
976 XFillRectangle (display
, window
, face
->gc
,
978 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
981 row
->visible_height
);
983 XSetForeground (display
, face
->gc
, face
->foreground
);
986 if (which
!= NO_FRINGE_BITMAP
)
988 /* Draw the bitmap. I believe these small pixmaps can be cached
990 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, wd
, h
,
992 face
->background
, depth
);
993 XCopyArea (display
, pixmap
, window
, gc
, 0, 0, wd
, h
, x
, y
+ dy
);
994 XFreePixmap (display
, pixmap
);
997 XSetClipMask (display
, gc
, None
);
1001 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
1002 function with input blocked. */
1005 x_draw_row_fringe_bitmaps (w
, row
)
1007 struct glyph_row
*row
;
1009 struct frame
*f
= XFRAME (w
->frame
);
1010 enum fringe_bitmap_type bitmap
;
1012 xassert (interrupt_input_blocked
);
1014 /* If row is completely invisible, because of vscrolling, we
1015 don't have to draw anything. */
1016 if (row
->visible_height
<= 0)
1019 if (FRAME_X_LEFT_FRINGE_WIDTH (f
) != 0)
1021 /* Decide which bitmap to draw in the left fringe. */
1022 if (row
->overlay_arrow_p
)
1023 bitmap
= OVERLAY_ARROW_BITMAP
;
1024 else if (row
->truncated_on_left_p
)
1025 bitmap
= LEFT_TRUNCATION_BITMAP
;
1026 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
1027 bitmap
= CONTINUATION_LINE_BITMAP
;
1028 else if (row
->indicate_empty_line_p
)
1029 bitmap
= ZV_LINE_BITMAP
;
1031 bitmap
= NO_FRINGE_BITMAP
;
1033 x_draw_fringe_bitmap (w
, row
, bitmap
, 1);
1036 if (FRAME_X_RIGHT_FRINGE_WIDTH (f
) != 0)
1038 /* Decide which bitmap to draw in the right fringe. */
1039 if (row
->truncated_on_right_p
)
1040 bitmap
= RIGHT_TRUNCATION_BITMAP
;
1041 else if (row
->continued_p
)
1042 bitmap
= CONTINUED_LINE_BITMAP
;
1043 else if (row
->indicate_empty_line_p
&& FRAME_X_LEFT_FRINGE_WIDTH (f
) == 0)
1044 bitmap
= ZV_LINE_BITMAP
;
1046 bitmap
= NO_FRINGE_BITMAP
;
1048 x_draw_fringe_bitmap (w
, row
, bitmap
, 0);
1054 /* This is called when starting Emacs and when restarting after
1055 suspend. When starting Emacs, no X window is mapped. And nothing
1056 must be done to Emacs's own window if it is suspended (though that
1060 XTset_terminal_modes ()
1064 /* This is called when exiting or suspending Emacs. Exiting will make
1065 the X-windows go away, and suspending requires no action. */
1068 XTreset_terminal_modes ()
1074 /***********************************************************************
1076 ***********************************************************************/
1078 /* Set the global variable output_cursor to CURSOR. All cursor
1079 positions are relative to updated_window. */
1082 set_output_cursor (cursor
)
1083 struct cursor_pos
*cursor
;
1085 output_cursor
.hpos
= cursor
->hpos
;
1086 output_cursor
.vpos
= cursor
->vpos
;
1087 output_cursor
.x
= cursor
->x
;
1088 output_cursor
.y
= cursor
->y
;
1092 /* Set a nominal cursor position.
1094 HPOS and VPOS are column/row positions in a window glyph matrix. X
1095 and Y are window text area relative pixel positions.
1097 If this is done during an update, updated_window will contain the
1098 window that is being updated and the position is the future output
1099 cursor position for that window. If updated_window is null, use
1100 selected_window and display the cursor at the given position. */
1103 XTcursor_to (vpos
, hpos
, y
, x
)
1104 int vpos
, hpos
, y
, x
;
1108 /* If updated_window is not set, work on selected_window. */
1112 w
= XWINDOW (selected_window
);
1114 /* Set the output cursor. */
1115 output_cursor
.hpos
= hpos
;
1116 output_cursor
.vpos
= vpos
;
1117 output_cursor
.x
= x
;
1118 output_cursor
.y
= y
;
1120 /* If not called as part of an update, really display the cursor.
1121 This will also set the cursor position of W. */
1122 if (updated_window
== NULL
)
1125 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1126 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1133 /***********************************************************************
1135 ***********************************************************************/
1137 /* Function prototypes of this page. */
1139 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1143 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1144 int, XChar2b
*, int,
1146 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
1147 static void x_encode_char
P_ ((int, XChar2b
*, struct font_info
*));
1148 static void x_append_glyph
P_ ((struct it
*));
1149 static void x_append_composite_glyph
P_ ((struct it
*));
1150 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1152 static void x_produce_glyphs
P_ ((struct it
*));
1153 static void x_produce_image_glyph
P_ ((struct it
*it
));
1156 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1157 is not contained in the font. */
1159 static INLINE XCharStruct
*
1160 x_per_char_metric (font
, char2b
)
1164 /* The result metric information. */
1165 XCharStruct
*pcm
= NULL
;
1167 xassert (font
&& char2b
);
1169 if (font
->per_char
!= NULL
)
1171 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
1173 /* min_char_or_byte2 specifies the linear character index
1174 corresponding to the first element of the per_char array,
1175 max_char_or_byte2 is the index of the last character. A
1176 character with non-zero CHAR2B->byte1 is not in the font.
1177 A character with byte2 less than min_char_or_byte2 or
1178 greater max_char_or_byte2 is not in the font. */
1179 if (char2b
->byte1
== 0
1180 && char2b
->byte2
>= font
->min_char_or_byte2
1181 && char2b
->byte2
<= font
->max_char_or_byte2
)
1182 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
1186 /* If either min_byte1 or max_byte1 are nonzero, both
1187 min_char_or_byte2 and max_char_or_byte2 are less than
1188 256, and the 2-byte character index values corresponding
1189 to the per_char array element N (counting from 0) are:
1191 byte1 = N/D + min_byte1
1192 byte2 = N\D + min_char_or_byte2
1196 D = max_char_or_byte2 - min_char_or_byte2 + 1
1197 / = integer division
1198 \ = integer modulus */
1199 if (char2b
->byte1
>= font
->min_byte1
1200 && char2b
->byte1
<= font
->max_byte1
1201 && char2b
->byte2
>= font
->min_char_or_byte2
1202 && char2b
->byte2
<= font
->max_char_or_byte2
)
1204 pcm
= (font
->per_char
1205 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
1206 * (char2b
->byte1
- font
->min_byte1
))
1207 + (char2b
->byte2
- font
->min_char_or_byte2
));
1213 /* If the per_char pointer is null, all glyphs between the first
1214 and last character indexes inclusive have the same
1215 information, as given by both min_bounds and max_bounds. */
1216 if (char2b
->byte2
>= font
->min_char_or_byte2
1217 && char2b
->byte2
<= font
->max_char_or_byte2
)
1218 pcm
= &font
->max_bounds
;
1221 return ((pcm
== NULL
1222 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
1227 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1228 the two-byte form of C. Encoding is returned in *CHAR2B. */
1231 x_encode_char (c
, char2b
, font_info
)
1234 struct font_info
*font_info
;
1236 int charset
= CHAR_CHARSET (c
);
1237 XFontStruct
*font
= font_info
->font
;
1239 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1240 This may be either a program in a special encoder language or a
1242 if (font_info
->font_encoder
)
1244 /* It's a program. */
1245 struct ccl_program
*ccl
= font_info
->font_encoder
;
1247 if (CHARSET_DIMENSION (charset
) == 1)
1249 ccl
->reg
[0] = charset
;
1250 ccl
->reg
[1] = char2b
->byte2
;
1254 ccl
->reg
[0] = charset
;
1255 ccl
->reg
[1] = char2b
->byte1
;
1256 ccl
->reg
[2] = char2b
->byte2
;
1259 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1261 /* We assume that MSBs are appropriately set/reset by CCL
1263 if (font
->max_byte1
== 0) /* 1-byte font */
1264 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
1266 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
1268 else if (font_info
->encoding
[charset
])
1270 /* Fixed encoding scheme. See fontset.h for the meaning of the
1271 encoding numbers. */
1272 int enc
= font_info
->encoding
[charset
];
1274 if ((enc
== 1 || enc
== 2)
1275 && CHARSET_DIMENSION (charset
) == 2)
1276 char2b
->byte1
|= 0x80;
1278 if (enc
== 1 || enc
== 3)
1279 char2b
->byte2
|= 0x80;
1284 /* Get face and two-byte form of character C in face FACE_ID on frame
1285 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1286 means we want to display multibyte text. DISPLAY_P non-zero means
1287 make sure that X resources for the face returned are allocated.
1288 Value is a pointer to a realized face that is ready for display if
1289 DISPLAY_P is non-zero. */
1291 static INLINE
struct face
*
1292 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
, display_p
)
1296 int multibyte_p
, display_p
;
1298 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1302 /* Unibyte case. We don't have to encode, but we have to make
1303 sure to use a face suitable for unibyte. */
1306 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1307 face
= FACE_FROM_ID (f
, face_id
);
1309 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1311 /* Case of ASCII in a face known to fit ASCII. */
1317 int c1
, c2
, charset
;
1319 /* Split characters into bytes. If c2 is -1 afterwards, C is
1320 really a one-byte character so that byte1 is zero. */
1321 SPLIT_CHAR (c
, charset
, c1
, c2
);
1323 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1325 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1327 /* Maybe encode the character in *CHAR2B. */
1328 if (face
->font
!= NULL
)
1330 struct font_info
*font_info
1331 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1333 x_encode_char (c
, char2b
, font_info
);
1337 /* Make sure X resources of the face are allocated. */
1340 xassert (face
!= NULL
);
1341 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1348 /* Get face and two-byte form of character glyph GLYPH on frame F.
1349 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1350 a pointer to a realized face that is ready for display. */
1352 static INLINE
struct face
*
1353 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1355 struct glyph
*glyph
;
1361 xassert (glyph
->type
== CHAR_GLYPH
);
1362 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1367 if (!glyph
->multibyte_p
)
1369 /* Unibyte case. We don't have to encode, but we have to make
1370 sure to use a face suitable for unibyte. */
1372 char2b
->byte2
= glyph
->u
.ch
;
1374 else if (glyph
->u
.ch
< 128
1375 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1377 /* Case of ASCII in a face known to fit ASCII. */
1379 char2b
->byte2
= glyph
->u
.ch
;
1383 int c1
, c2
, charset
;
1385 /* Split characters into bytes. If c2 is -1 afterwards, C is
1386 really a one-byte character so that byte1 is zero. */
1387 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1389 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1391 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1393 /* Maybe encode the character in *CHAR2B. */
1394 if (charset
!= CHARSET_ASCII
)
1396 struct font_info
*font_info
1397 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1400 x_encode_char (glyph
->u
.ch
, char2b
, font_info
);
1403 = ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
1408 /* Make sure X resources of the face are allocated. */
1409 xassert (face
!= NULL
);
1410 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1415 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1416 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1422 struct glyph
*glyph
;
1423 enum glyph_row_area area
= it
->area
;
1425 xassert (it
->glyph_row
);
1426 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1428 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1429 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1431 glyph
->charpos
= CHARPOS (it
->position
);
1432 glyph
->object
= it
->object
;
1433 glyph
->pixel_width
= it
->pixel_width
;
1434 glyph
->voffset
= it
->voffset
;
1435 glyph
->type
= CHAR_GLYPH
;
1436 glyph
->multibyte_p
= it
->multibyte_p
;
1437 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1438 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1439 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1440 || it
->phys_descent
> it
->descent
);
1441 glyph
->padding_p
= 0;
1442 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1443 glyph
->face_id
= it
->face_id
;
1444 glyph
->u
.ch
= it
->char_to_display
;
1445 ++it
->glyph_row
->used
[area
];
1449 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1450 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1453 x_append_composite_glyph (it
)
1456 struct glyph
*glyph
;
1457 enum glyph_row_area area
= it
->area
;
1459 xassert (it
->glyph_row
);
1461 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1462 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1464 glyph
->charpos
= CHARPOS (it
->position
);
1465 glyph
->object
= it
->object
;
1466 glyph
->pixel_width
= it
->pixel_width
;
1467 glyph
->voffset
= it
->voffset
;
1468 glyph
->type
= COMPOSITE_GLYPH
;
1469 glyph
->multibyte_p
= it
->multibyte_p
;
1470 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1471 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1472 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1473 || it
->phys_descent
> it
->descent
);
1474 glyph
->padding_p
= 0;
1475 glyph
->glyph_not_available_p
= 0;
1476 glyph
->face_id
= it
->face_id
;
1477 glyph
->u
.cmp_id
= it
->cmp_id
;
1478 ++it
->glyph_row
->used
[area
];
1483 /* Change IT->ascent and IT->height according to the setting of
1487 take_vertical_position_into_account (it
)
1492 if (it
->voffset
< 0)
1493 /* Increase the ascent so that we can display the text higher
1495 it
->ascent
+= abs (it
->voffset
);
1497 /* Increase the descent so that we can display the text lower
1499 it
->descent
+= it
->voffset
;
1504 /* Produce glyphs/get display metrics for the image IT is loaded with.
1505 See the description of struct display_iterator in dispextern.h for
1506 an overview of struct display_iterator. */
1509 x_produce_image_glyph (it
)
1515 xassert (it
->what
== IT_IMAGE
);
1517 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1518 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1521 /* Make sure X resources of the face and image are loaded. */
1522 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1523 prepare_image_for_display (it
->f
, img
);
1525 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1526 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->vmargin
- it
->ascent
;
1527 it
->pixel_width
= img
->width
+ 2 * img
->hmargin
;
1531 if (face
->box
!= FACE_NO_BOX
)
1533 if (face
->box_line_width
> 0)
1535 it
->ascent
+= face
->box_line_width
;
1536 it
->descent
+= face
->box_line_width
;
1539 if (it
->start_of_box_run_p
)
1540 it
->pixel_width
+= abs (face
->box_line_width
);
1541 if (it
->end_of_box_run_p
)
1542 it
->pixel_width
+= abs (face
->box_line_width
);
1545 take_vertical_position_into_account (it
);
1549 struct glyph
*glyph
;
1550 enum glyph_row_area area
= it
->area
;
1552 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1553 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1555 glyph
->charpos
= CHARPOS (it
->position
);
1556 glyph
->object
= it
->object
;
1557 glyph
->pixel_width
= it
->pixel_width
;
1558 glyph
->voffset
= it
->voffset
;
1559 glyph
->type
= IMAGE_GLYPH
;
1560 glyph
->multibyte_p
= it
->multibyte_p
;
1561 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1562 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1563 glyph
->overlaps_vertically_p
= 0;
1564 glyph
->padding_p
= 0;
1565 glyph
->glyph_not_available_p
= 0;
1566 glyph
->face_id
= it
->face_id
;
1567 glyph
->u
.img_id
= img
->id
;
1568 ++it
->glyph_row
->used
[area
];
1574 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1575 of the glyph, WIDTH and HEIGHT are the width and height of the
1576 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1577 ascent of the glyph (0 <= ASCENT <= 1). */
1580 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1586 struct glyph
*glyph
;
1587 enum glyph_row_area area
= it
->area
;
1589 xassert (ascent
>= 0 && ascent
<= 1);
1591 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1592 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1594 glyph
->charpos
= CHARPOS (it
->position
);
1595 glyph
->object
= object
;
1596 glyph
->pixel_width
= width
;
1597 glyph
->voffset
= it
->voffset
;
1598 glyph
->type
= STRETCH_GLYPH
;
1599 glyph
->multibyte_p
= it
->multibyte_p
;
1600 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1601 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1602 glyph
->overlaps_vertically_p
= 0;
1603 glyph
->padding_p
= 0;
1604 glyph
->glyph_not_available_p
= 0;
1605 glyph
->face_id
= it
->face_id
;
1606 glyph
->u
.stretch
.ascent
= height
* ascent
;
1607 glyph
->u
.stretch
.height
= height
;
1608 ++it
->glyph_row
->used
[area
];
1613 /* Produce a stretch glyph for iterator IT. IT->object is the value
1614 of the glyph property displayed. The value must be a list
1615 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1618 1. `:width WIDTH' specifies that the space should be WIDTH *
1619 canonical char width wide. WIDTH may be an integer or floating
1622 2. `:relative-width FACTOR' specifies that the width of the stretch
1623 should be computed from the width of the first character having the
1624 `glyph' property, and should be FACTOR times that width.
1626 3. `:align-to HPOS' specifies that the space should be wide enough
1627 to reach HPOS, a value in canonical character units.
1629 Exactly one of the above pairs must be present.
1631 4. `:height HEIGHT' specifies that the height of the stretch produced
1632 should be HEIGHT, measured in canonical character units.
1634 5. `:relative-height FACTOR' specifies that the height of the
1635 stretch should be FACTOR times the height of the characters having
1638 Either none or exactly one of 4 or 5 must be present.
1640 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1641 of the stretch should be used for the ascent of the stretch.
1642 ASCENT must be in the range 0 <= ASCENT <= 100. */
1645 ((INTEGERP (X) || FLOATP (X)) \
1651 x_produce_stretch_glyph (it
)
1654 /* (space :width WIDTH :height HEIGHT. */
1656 extern Lisp_Object Qspace
;
1658 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
1659 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1660 extern Lisp_Object QCalign_to
;
1661 Lisp_Object prop
, plist
;
1662 double width
= 0, height
= 0, ascent
= 0;
1663 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1664 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1666 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1668 /* List should start with `space'. */
1669 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1670 plist
= XCDR (it
->object
);
1672 /* Compute the width of the stretch. */
1673 if (prop
= Fplist_get (plist
, QCwidth
),
1675 /* Absolute width `:width WIDTH' specified and valid. */
1676 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1677 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1680 /* Relative width `:relative-width FACTOR' specified and valid.
1681 Compute the width of the characters having the `glyph'
1684 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1687 if (it
->multibyte_p
)
1689 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1690 - IT_BYTEPOS (*it
));
1691 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1694 it2
.c
= *p
, it2
.len
= 1;
1696 it2
.glyph_row
= NULL
;
1697 it2
.what
= IT_CHARACTER
;
1698 x_produce_glyphs (&it2
);
1699 width
= NUMVAL (prop
) * it2
.pixel_width
;
1701 else if (prop
= Fplist_get (plist
, QCalign_to
),
1703 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1705 /* Nothing specified -> width defaults to canonical char width. */
1706 width
= CANON_X_UNIT (it
->f
);
1708 /* Compute height. */
1709 if (prop
= Fplist_get (plist
, QCheight
),
1711 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1712 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1714 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1716 height
= FONT_HEIGHT (font
);
1718 /* Compute percentage of height used for ascent. If
1719 `:ascent ASCENT' is present and valid, use that. Otherwise,
1720 derive the ascent from the font in use. */
1721 if (prop
= Fplist_get (plist
, QCascent
),
1722 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1723 ascent
= NUMVAL (prop
) / 100.0;
1725 ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1734 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1735 if (!STRINGP (object
))
1736 object
= it
->w
->buffer
;
1737 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1740 it
->pixel_width
= width
;
1741 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1742 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1745 if (face
->box
!= FACE_NO_BOX
)
1747 if (face
->box_line_width
> 0)
1749 it
->ascent
+= face
->box_line_width
;
1750 it
->descent
+= face
->box_line_width
;
1753 if (it
->start_of_box_run_p
)
1754 it
->pixel_width
+= abs (face
->box_line_width
);
1755 if (it
->end_of_box_run_p
)
1756 it
->pixel_width
+= abs (face
->box_line_width
);
1759 take_vertical_position_into_account (it
);
1762 /* Return proper value to be used as baseline offset of font that has
1763 ASCENT and DESCENT to draw characters by the font at the vertical
1764 center of the line of frame F.
1766 Here, out task is to find the value of BOFF in the following figure;
1768 -------------------------+-----------+-
1769 -+-+---------+-+ | |
1771 | | | | F_ASCENT F_HEIGHT
1774 | | |-|-+------+-----------|------- baseline
1776 | |---------|-+-+ | |
1778 -+-+---------+-+ F_DESCENT |
1779 -------------------------+-----------+-
1781 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1782 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1783 DESCENT = FONT->descent
1784 HEIGHT = FONT_HEIGHT (FONT)
1785 F_DESCENT = (F->output_data.x->font->descent
1786 - F->output_data.x->baseline_offset)
1787 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1790 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1792 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
1793 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
1794 - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
1796 /* Produce glyphs/get display metrics for the display element IT is
1797 loaded with. See the description of struct display_iterator in
1798 dispextern.h for an overview of struct display_iterator. */
1801 x_produce_glyphs (it
)
1804 it
->glyph_not_available_p
= 0;
1806 if (it
->what
== IT_CHARACTER
)
1810 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1812 int font_not_found_p
;
1813 struct font_info
*font_info
;
1814 int boff
; /* baseline offset */
1815 /* We may change it->multibyte_p upon unibyte<->multibyte
1816 conversion. So, save the current value now and restore it
1819 Note: It seems that we don't have to record multibyte_p in
1820 struct glyph because the character code itself tells if or
1821 not the character is multibyte. Thus, in the future, we must
1822 consider eliminating the field `multibyte_p' in the struct
1824 int saved_multibyte_p
= it
->multibyte_p
;
1826 /* Maybe translate single-byte characters to multibyte, or the
1828 it
->char_to_display
= it
->c
;
1829 if (!ASCII_BYTE_P (it
->c
))
1831 if (unibyte_display_via_language_environment
1832 && SINGLE_BYTE_CHAR_P (it
->c
)
1834 || !NILP (Vnonascii_translation_table
)))
1836 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
1837 it
->multibyte_p
= 1;
1838 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1839 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1841 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
1842 && !it
->multibyte_p
)
1844 it
->multibyte_p
= 1;
1845 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1846 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1850 /* Get font to use. Encode IT->char_to_display. */
1851 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
1852 it
->face_id
, &char2b
,
1853 it
->multibyte_p
, 0);
1856 /* When no suitable font found, use the default font. */
1857 font_not_found_p
= font
== NULL
;
1858 if (font_not_found_p
)
1860 font
= FRAME_FONT (it
->f
);
1861 boff
= it
->f
->output_data
.x
->baseline_offset
;
1866 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
1867 boff
= font_info
->baseline_offset
;
1868 if (font_info
->vertical_centering
)
1869 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
1872 if (it
->char_to_display
>= ' '
1873 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
1875 /* Either unibyte or ASCII. */
1880 pcm
= x_per_char_metric (font
, &char2b
);
1881 it
->ascent
= font
->ascent
+ boff
;
1882 it
->descent
= font
->descent
- boff
;
1886 it
->phys_ascent
= pcm
->ascent
+ boff
;
1887 it
->phys_descent
= pcm
->descent
- boff
;
1888 it
->pixel_width
= pcm
->width
;
1892 it
->glyph_not_available_p
= 1;
1893 it
->phys_ascent
= font
->ascent
+ boff
;
1894 it
->phys_descent
= font
->descent
- boff
;
1895 it
->pixel_width
= FONT_WIDTH (font
);
1898 /* If this is a space inside a region of text with
1899 `space-width' property, change its width. */
1900 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
1902 it
->pixel_width
*= XFLOATINT (it
->space_width
);
1904 /* If face has a box, add the box thickness to the character
1905 height. If character has a box line to the left and/or
1906 right, add the box line width to the character's width. */
1907 if (face
->box
!= FACE_NO_BOX
)
1909 int thick
= face
->box_line_width
;
1913 it
->ascent
+= thick
;
1914 it
->descent
+= thick
;
1919 if (it
->start_of_box_run_p
)
1920 it
->pixel_width
+= thick
;
1921 if (it
->end_of_box_run_p
)
1922 it
->pixel_width
+= thick
;
1925 /* If face has an overline, add the height of the overline
1926 (1 pixel) and a 1 pixel margin to the character height. */
1927 if (face
->overline_p
)
1930 take_vertical_position_into_account (it
);
1932 /* If we have to actually produce glyphs, do it. */
1937 /* Translate a space with a `space-width' property
1938 into a stretch glyph. */
1939 double ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1940 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1941 it
->ascent
+ it
->descent
, ascent
);
1944 x_append_glyph (it
);
1946 /* If characters with lbearing or rbearing are displayed
1947 in this line, record that fact in a flag of the
1948 glyph row. This is used to optimize X output code. */
1949 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
1950 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1953 else if (it
->char_to_display
== '\n')
1955 /* A newline has no width but we need the height of the line. */
1956 it
->pixel_width
= 0;
1958 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1959 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1961 if (face
->box
!= FACE_NO_BOX
1962 && face
->box_line_width
> 0)
1964 it
->ascent
+= face
->box_line_width
;
1965 it
->descent
+= face
->box_line_width
;
1968 else if (it
->char_to_display
== '\t')
1970 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
1971 int x
= it
->current_x
+ it
->continuation_lines_width
;
1972 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
1974 /* If the distance from the current position to the next tab
1975 stop is less than a canonical character width, use the
1976 tab stop after that. */
1977 if (next_tab_x
- x
< CANON_X_UNIT (it
->f
))
1978 next_tab_x
+= tab_width
;
1980 it
->pixel_width
= next_tab_x
- x
;
1982 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1983 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1987 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
1988 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1989 it
->ascent
+ it
->descent
, ascent
);
1994 /* A multi-byte character. Assume that the display width of the
1995 character is the width of the character multiplied by the
1996 width of the font. */
1998 /* If we found a font, this font should give us the right
1999 metrics. If we didn't find a font, use the frame's
2000 default font and calculate the width of the character
2001 from the charset width; this is what old redisplay code
2003 pcm
= x_per_char_metric (font
, &char2b
);
2004 if (font_not_found_p
|| !pcm
)
2006 int charset
= CHAR_CHARSET (it
->char_to_display
);
2008 it
->glyph_not_available_p
= 1;
2009 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
2010 * CHARSET_WIDTH (charset
));
2011 it
->phys_ascent
= font
->ascent
+ boff
;
2012 it
->phys_descent
= font
->descent
- boff
;
2016 it
->pixel_width
= pcm
->width
;
2017 it
->phys_ascent
= pcm
->ascent
+ boff
;
2018 it
->phys_descent
= pcm
->descent
- boff
;
2020 && (pcm
->lbearing
< 0
2021 || pcm
->rbearing
> pcm
->width
))
2022 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2025 it
->ascent
= font
->ascent
+ boff
;
2026 it
->descent
= font
->descent
- boff
;
2027 if (face
->box
!= FACE_NO_BOX
)
2029 int thick
= face
->box_line_width
;
2033 it
->ascent
+= thick
;
2034 it
->descent
+= thick
;
2039 if (it
->start_of_box_run_p
)
2040 it
->pixel_width
+= thick
;
2041 if (it
->end_of_box_run_p
)
2042 it
->pixel_width
+= thick
;
2045 /* If face has an overline, add the height of the overline
2046 (1 pixel) and a 1 pixel margin to the character height. */
2047 if (face
->overline_p
)
2050 take_vertical_position_into_account (it
);
2053 x_append_glyph (it
);
2055 it
->multibyte_p
= saved_multibyte_p
;
2057 else if (it
->what
== IT_COMPOSITION
)
2059 /* Note: A composition is represented as one glyph in the
2060 glyph matrix. There are no padding glyphs. */
2063 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2065 int font_not_found_p
;
2066 struct font_info
*font_info
;
2067 int boff
; /* baseline offset */
2068 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2070 /* Maybe translate single-byte characters to multibyte. */
2071 it
->char_to_display
= it
->c
;
2072 if (unibyte_display_via_language_environment
2073 && SINGLE_BYTE_CHAR_P (it
->c
)
2076 && !NILP (Vnonascii_translation_table
))))
2078 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2081 /* Get face and font to use. Encode IT->char_to_display. */
2082 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2083 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2084 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2085 it
->face_id
, &char2b
, it
->multibyte_p
, 0);
2088 /* When no suitable font found, use the default font. */
2089 font_not_found_p
= font
== NULL
;
2090 if (font_not_found_p
)
2092 font
= FRAME_FONT (it
->f
);
2093 boff
= it
->f
->output_data
.x
->baseline_offset
;
2098 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2099 boff
= font_info
->baseline_offset
;
2100 if (font_info
->vertical_centering
)
2101 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2104 /* There are no padding glyphs, so there is only one glyph to
2105 produce for the composition. Important is that pixel_width,
2106 ascent and descent are the values of what is drawn by
2107 draw_glyphs (i.e. the values of the overall glyphs composed). */
2110 /* If we have not yet calculated pixel size data of glyphs of
2111 the composition for the current face font, calculate them
2112 now. Theoretically, we have to check all fonts for the
2113 glyphs, but that requires much time and memory space. So,
2114 here we check only the font of the first glyph. This leads
2115 to incorrect display very rarely, and C-l (recenter) can
2116 correct the display anyway. */
2117 if (cmp
->font
!= (void *) font
)
2119 /* Ascent and descent of the font of the first character of
2120 this composition (adjusted by baseline offset). Ascent
2121 and descent of overall glyphs should not be less than
2122 them respectively. */
2123 int font_ascent
= font
->ascent
+ boff
;
2124 int font_descent
= font
->descent
- boff
;
2125 /* Bounding box of the overall glyphs. */
2126 int leftmost
, rightmost
, lowest
, highest
;
2127 int i
, width
, ascent
, descent
;
2129 cmp
->font
= (void *) font
;
2131 /* Initialize the bounding box. */
2133 && (pcm
= x_per_char_metric (font
, &char2b
)))
2136 ascent
= pcm
->ascent
;
2137 descent
= pcm
->descent
;
2141 width
= FONT_WIDTH (font
);
2142 ascent
= font
->ascent
;
2143 descent
= font
->descent
;
2147 lowest
= - descent
+ boff
;
2148 highest
= ascent
+ boff
;
2152 && font_info
->default_ascent
2153 && CHAR_TABLE_P (Vuse_default_ascent
)
2154 && !NILP (Faref (Vuse_default_ascent
,
2155 make_number (it
->char_to_display
))))
2156 highest
= font_info
->default_ascent
+ boff
;
2158 /* Draw the first glyph at the normal position. It may be
2159 shifted to right later if some other glyphs are drawn at
2161 cmp
->offsets
[0] = 0;
2162 cmp
->offsets
[1] = boff
;
2164 /* Set cmp->offsets for the remaining glyphs. */
2165 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2167 int left
, right
, btm
, top
;
2168 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2169 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2171 face
= FACE_FROM_ID (it
->f
, face_id
);
2172 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2173 it
->multibyte_p
, 0);
2177 font
= FRAME_FONT (it
->f
);
2178 boff
= it
->f
->output_data
.x
->baseline_offset
;
2184 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2185 boff
= font_info
->baseline_offset
;
2186 if (font_info
->vertical_centering
)
2187 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2191 && (pcm
= x_per_char_metric (font
, &char2b
)))
2194 ascent
= pcm
->ascent
;
2195 descent
= pcm
->descent
;
2199 width
= FONT_WIDTH (font
);
2204 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2206 /* Relative composition with or without
2208 left
= (leftmost
+ rightmost
- width
) / 2;
2209 btm
= - descent
+ boff
;
2210 if (font_info
&& font_info
->relative_compose
2211 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2212 || NILP (Faref (Vignore_relative_composition
,
2213 make_number (ch
)))))
2216 if (- descent
>= font_info
->relative_compose
)
2217 /* One extra pixel between two glyphs. */
2219 else if (ascent
<= 0)
2220 /* One extra pixel between two glyphs. */
2221 btm
= lowest
- 1 - ascent
- descent
;
2226 /* A composition rule is specified by an integer
2227 value that encodes global and new reference
2228 points (GREF and NREF). GREF and NREF are
2229 specified by numbers as below:
2237 ---3---4---5--- baseline
2239 6---7---8 -- descent
2241 int rule
= COMPOSITION_RULE (cmp
, i
);
2242 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2244 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2245 grefx
= gref
% 3, nrefx
= nref
% 3;
2246 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2249 + grefx
* (rightmost
- leftmost
) / 2
2250 - nrefx
* width
/ 2);
2251 btm
= ((grefy
== 0 ? highest
2253 : grefy
== 2 ? lowest
2254 : (highest
+ lowest
) / 2)
2255 - (nrefy
== 0 ? ascent
+ descent
2256 : nrefy
== 1 ? descent
- boff
2258 : (ascent
+ descent
) / 2));
2261 cmp
->offsets
[i
* 2] = left
;
2262 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2264 /* Update the bounding box of the overall glyphs. */
2265 right
= left
+ width
;
2266 top
= btm
+ descent
+ ascent
;
2267 if (left
< leftmost
)
2269 if (right
> rightmost
)
2277 /* If there are glyphs whose x-offsets are negative,
2278 shift all glyphs to the right and make all x-offsets
2282 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2283 cmp
->offsets
[i
* 2] -= leftmost
;
2284 rightmost
-= leftmost
;
2287 cmp
->pixel_width
= rightmost
;
2288 cmp
->ascent
= highest
;
2289 cmp
->descent
= - lowest
;
2290 if (cmp
->ascent
< font_ascent
)
2291 cmp
->ascent
= font_ascent
;
2292 if (cmp
->descent
< font_descent
)
2293 cmp
->descent
= font_descent
;
2296 it
->pixel_width
= cmp
->pixel_width
;
2297 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2298 it
->descent
= it
->phys_descent
= cmp
->descent
;
2300 if (face
->box
!= FACE_NO_BOX
)
2302 int thick
= face
->box_line_width
;
2306 it
->ascent
+= thick
;
2307 it
->descent
+= thick
;
2312 if (it
->start_of_box_run_p
)
2313 it
->pixel_width
+= thick
;
2314 if (it
->end_of_box_run_p
)
2315 it
->pixel_width
+= thick
;
2318 /* If face has an overline, add the height of the overline
2319 (1 pixel) and a 1 pixel margin to the character height. */
2320 if (face
->overline_p
)
2323 take_vertical_position_into_account (it
);
2326 x_append_composite_glyph (it
);
2328 else if (it
->what
== IT_IMAGE
)
2329 x_produce_image_glyph (it
);
2330 else if (it
->what
== IT_STRETCH
)
2331 x_produce_stretch_glyph (it
);
2333 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2334 because this isn't true for images with `:ascent 100'. */
2335 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2336 if (it
->area
== TEXT_AREA
)
2337 it
->current_x
+= it
->pixel_width
;
2339 it
->descent
+= it
->extra_line_spacing
;
2341 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2342 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2343 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2344 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2348 /* Estimate the pixel height of the mode or top line on frame F.
2349 FACE_ID specifies what line's height to estimate. */
2352 x_estimate_mode_line_height (f
, face_id
)
2354 enum face_id face_id
;
2356 int height
= FONT_HEIGHT (FRAME_FONT (f
));
2358 /* This function is called so early when Emacs starts that the face
2359 cache and mode line face are not yet initialized. */
2360 if (FRAME_FACE_CACHE (f
))
2362 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2366 height
= FONT_HEIGHT (face
->font
);
2367 if (face
->box_line_width
> 0)
2368 height
+= 2 * face
->box_line_width
;
2376 /***********************************************************************
2378 ***********************************************************************/
2380 /* A sequence of glyphs to be drawn in the same face.
2382 This data structure is not really completely X specific, so it
2383 could possibly, at least partially, be useful for other systems. It
2384 is currently not part of the external redisplay interface because
2385 it's not clear what other systems will need. */
2389 /* X-origin of the string. */
2392 /* Y-origin and y-position of the base line of this string. */
2395 /* The width of the string, not including a face extension. */
2398 /* The width of the string, including a face extension. */
2399 int background_width
;
2401 /* The height of this string. This is the height of the line this
2402 string is drawn in, and can be different from the height of the
2403 font the string is drawn in. */
2406 /* Number of pixels this string overwrites in front of its x-origin.
2407 This number is zero if the string has an lbearing >= 0; it is
2408 -lbearing, if the string has an lbearing < 0. */
2411 /* Number of pixels this string overwrites past its right-most
2412 nominal x-position, i.e. x + width. Zero if the string's
2413 rbearing is <= its nominal width, rbearing - width otherwise. */
2416 /* The frame on which the glyph string is drawn. */
2419 /* The window on which the glyph string is drawn. */
2422 /* X display and window for convenience. */
2426 /* The glyph row for which this string was built. It determines the
2427 y-origin and height of the string. */
2428 struct glyph_row
*row
;
2430 /* The area within row. */
2431 enum glyph_row_area area
;
2433 /* Characters to be drawn, and number of characters. */
2437 /* A face-override for drawing cursors, mouse face and similar. */
2438 enum draw_glyphs_face hl
;
2440 /* Face in which this string is to be drawn. */
2443 /* Font in which this string is to be drawn. */
2446 /* Font info for this string. */
2447 struct font_info
*font_info
;
2449 /* Non-null means this string describes (part of) a composition.
2450 All characters from char2b are drawn composed. */
2451 struct composition
*cmp
;
2453 /* Index of this glyph string's first character in the glyph
2454 definition of CMP. If this is zero, this glyph string describes
2455 the first character of a composition. */
2458 /* 1 means this glyph strings face has to be drawn to the right end
2459 of the window's drawing area. */
2460 unsigned extends_to_end_of_line_p
: 1;
2462 /* 1 means the background of this string has been drawn. */
2463 unsigned background_filled_p
: 1;
2465 /* 1 means glyph string must be drawn with 16-bit functions. */
2466 unsigned two_byte_p
: 1;
2468 /* 1 means that the original font determined for drawing this glyph
2469 string could not be loaded. The member `font' has been set to
2470 the frame's default font in this case. */
2471 unsigned font_not_found_p
: 1;
2473 /* 1 means that the face in which this glyph string is drawn has a
2475 unsigned stippled_p
: 1;
2477 /* 1 means only the foreground of this glyph string must be drawn,
2478 and we should use the physical height of the line this glyph
2479 string appears in as clip rect. */
2480 unsigned for_overlaps_p
: 1;
2482 /* The GC to use for drawing this glyph string. */
2485 /* A pointer to the first glyph in the string. This glyph
2486 corresponds to char2b[0]. Needed to draw rectangles if
2487 font_not_found_p is 1. */
2488 struct glyph
*first_glyph
;
2490 /* Image, if any. */
2493 struct glyph_string
*next
, *prev
;
2500 x_dump_glyph_string (s
)
2501 struct glyph_string
*s
;
2503 fprintf (stderr
, "glyph string\n");
2504 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2505 s
->x
, s
->y
, s
->width
, s
->height
);
2506 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2507 fprintf (stderr
, " hl = %d\n", s
->hl
);
2508 fprintf (stderr
, " left overhang = %d, right = %d\n",
2509 s
->left_overhang
, s
->right_overhang
);
2510 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2511 fprintf (stderr
, " extends to end of line = %d\n",
2512 s
->extends_to_end_of_line_p
);
2513 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2514 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2517 #endif /* GLYPH_DEBUG */
2521 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2522 struct glyph_string
**,
2523 struct glyph_string
*,
2524 struct glyph_string
*));
2525 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2526 struct glyph_string
**,
2527 struct glyph_string
*,
2528 struct glyph_string
*));
2529 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2530 struct glyph_string
**,
2531 struct glyph_string
*));
2532 static int x_left_overwritten
P_ ((struct glyph_string
*));
2533 static int x_left_overwriting
P_ ((struct glyph_string
*));
2534 static int x_right_overwritten
P_ ((struct glyph_string
*));
2535 static int x_right_overwriting
P_ ((struct glyph_string
*));
2536 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2538 static void x_init_glyph_string
P_ ((struct glyph_string
*,
2539 XChar2b
*, struct window
*,
2541 enum glyph_row_area
, int,
2542 enum draw_glyphs_face
));
2543 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2544 enum glyph_row_area
, int, int,
2545 enum draw_glyphs_face
, int));
2546 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2547 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2548 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2550 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2551 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2552 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2553 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2554 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2555 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2556 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2557 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2558 static void x_get_glyph_overhangs
P_ ((struct glyph
*, struct frame
*,
2560 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2561 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
2562 unsigned long *, double, int));
2563 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2564 double, int, unsigned long));
2565 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2566 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2567 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2568 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2569 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
2570 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2571 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2573 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2574 int, int, int, int, XRectangle
*));
2575 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2576 int, int, int, XRectangle
*));
2577 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2578 enum glyph_row_area
));
2579 static int x_fill_stretch_glyph_string
P_ ((struct glyph_string
*,
2581 enum glyph_row_area
, int, int));
2584 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2588 /* Append the list of glyph strings with head H and tail T to the list
2589 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2592 x_append_glyph_string_lists (head
, tail
, h
, t
)
2593 struct glyph_string
**head
, **tail
;
2594 struct glyph_string
*h
, *t
;
2608 /* Prepend the list of glyph strings with head H and tail T to the
2609 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2613 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2614 struct glyph_string
**head
, **tail
;
2615 struct glyph_string
*h
, *t
;
2629 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2630 Set *HEAD and *TAIL to the resulting list. */
2633 x_append_glyph_string (head
, tail
, s
)
2634 struct glyph_string
**head
, **tail
;
2635 struct glyph_string
*s
;
2637 s
->next
= s
->prev
= NULL
;
2638 x_append_glyph_string_lists (head
, tail
, s
, s
);
2642 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2647 struct glyph_string
*s
;
2649 if (s
->font
== FRAME_FONT (s
->f
)
2650 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2651 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2653 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
2656 /* Cursor on non-default face: must merge. */
2660 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
2661 xgcv
.foreground
= s
->face
->background
;
2663 /* If the glyph would be invisible, try a different foreground. */
2664 if (xgcv
.foreground
== xgcv
.background
)
2665 xgcv
.foreground
= s
->face
->foreground
;
2666 if (xgcv
.foreground
== xgcv
.background
)
2667 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
2668 if (xgcv
.foreground
== xgcv
.background
)
2669 xgcv
.foreground
= s
->face
->foreground
;
2671 /* Make sure the cursor is distinct from text in this face. */
2672 if (xgcv
.background
== s
->face
->background
2673 && xgcv
.foreground
== s
->face
->foreground
)
2675 xgcv
.background
= s
->face
->foreground
;
2676 xgcv
.foreground
= s
->face
->background
;
2679 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2680 xgcv
.font
= s
->font
->fid
;
2681 xgcv
.graphics_exposures
= False
;
2682 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2684 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2685 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2688 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2689 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2691 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2696 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2699 x_set_mouse_face_gc (s
)
2700 struct glyph_string
*s
;
2705 /* What face has to be used last for the mouse face? */
2706 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2707 face
= FACE_FROM_ID (s
->f
, face_id
);
2709 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
2711 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2712 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2714 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2715 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2716 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2718 /* If font in this face is same as S->font, use it. */
2719 if (s
->font
== s
->face
->font
)
2720 s
->gc
= s
->face
->gc
;
2723 /* Otherwise construct scratch_cursor_gc with values from FACE
2728 xgcv
.background
= s
->face
->background
;
2729 xgcv
.foreground
= s
->face
->foreground
;
2730 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2731 xgcv
.font
= s
->font
->fid
;
2732 xgcv
.graphics_exposures
= False
;
2733 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2735 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2736 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2739 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2740 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2742 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2745 xassert (s
->gc
!= 0);
2749 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2750 Faces to use in the mode line have already been computed when the
2751 matrix was built, so there isn't much to do, here. */
2754 x_set_mode_line_face_gc (s
)
2755 struct glyph_string
*s
;
2757 s
->gc
= s
->face
->gc
;
2761 /* Set S->gc of glyph string S for drawing that glyph string. Set
2762 S->stippled_p to a non-zero value if the face of S has a stipple
2766 x_set_glyph_string_gc (s
)
2767 struct glyph_string
*s
;
2769 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2771 if (s
->hl
== DRAW_NORMAL_TEXT
)
2773 s
->gc
= s
->face
->gc
;
2774 s
->stippled_p
= s
->face
->stipple
!= 0;
2776 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2778 x_set_mode_line_face_gc (s
);
2779 s
->stippled_p
= s
->face
->stipple
!= 0;
2781 else if (s
->hl
== DRAW_CURSOR
)
2783 x_set_cursor_gc (s
);
2786 else if (s
->hl
== DRAW_MOUSE_FACE
)
2788 x_set_mouse_face_gc (s
);
2789 s
->stippled_p
= s
->face
->stipple
!= 0;
2791 else if (s
->hl
== DRAW_IMAGE_RAISED
2792 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2794 s
->gc
= s
->face
->gc
;
2795 s
->stippled_p
= s
->face
->stipple
!= 0;
2799 s
->gc
= s
->face
->gc
;
2800 s
->stippled_p
= s
->face
->stipple
!= 0;
2803 /* GC must have been set. */
2804 xassert (s
->gc
!= 0);
2808 /* Return in *R the clipping rectangle for glyph string S. */
2811 x_get_glyph_string_clip_rect (s
, r
)
2812 struct glyph_string
*s
;
2815 if (s
->row
->full_width_p
)
2817 /* Draw full-width. X coordinates are relative to S->w->left. */
2818 int canon_x
= CANON_X_UNIT (s
->f
);
2820 r
->x
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
2821 r
->width
= XFASTINT (s
->w
->width
) * canon_x
;
2823 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
2825 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
2826 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
2830 r
->x
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
2832 /* Unless displaying a mode or menu bar line, which are always
2833 fully visible, clip to the visible part of the row. */
2834 if (s
->w
->pseudo_window_p
)
2835 r
->height
= s
->row
->visible_height
;
2837 r
->height
= s
->height
;
2841 /* This is a text line that may be partially visible. */
2842 r
->x
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
2843 r
->width
= window_box_width (s
->w
, s
->area
);
2844 r
->height
= s
->row
->visible_height
;
2847 /* If S draws overlapping rows, it's sufficient to use the top and
2848 bottom of the window for clipping because this glyph string
2849 intentionally draws over other lines. */
2850 if (s
->for_overlaps_p
)
2852 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2853 r
->height
= window_text_bottom_y (s
->w
) - r
->y
;
2857 /* Don't use S->y for clipping because it doesn't take partially
2858 visible lines into account. For example, it can be negative for
2859 partially visible lines at the top of a window. */
2860 if (!s
->row
->full_width_p
2861 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2862 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2864 r
->y
= max (0, s
->row
->y
);
2866 /* If drawing a tool-bar window, draw it over the internal border
2867 at the top of the window. */
2868 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
2869 r
->y
-= s
->f
->output_data
.x
->internal_border_width
;
2872 r
->y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->y
);
2876 /* Set clipping for output of glyph string S. S may be part of a mode
2877 line or menu if we don't have X toolkit support. */
2880 x_set_glyph_string_clipping (s
)
2881 struct glyph_string
*s
;
2884 x_get_glyph_string_clip_rect (s
, &r
);
2885 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
2889 /* Compute left and right overhang of glyph string S. If S is a glyph
2890 string for a composition, assume overhangs don't exist. */
2893 x_compute_glyph_string_overhangs (s
)
2894 struct glyph_string
*s
;
2897 && s
->first_glyph
->type
== CHAR_GLYPH
)
2900 int direction
, font_ascent
, font_descent
;
2901 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
2902 &font_ascent
, &font_descent
, &cs
);
2903 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2904 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2909 /* Compute overhangs and x-positions for glyph string S and its
2910 predecessors, or successors. X is the starting x-position for S.
2911 BACKWARD_P non-zero means process predecessors. */
2914 x_compute_overhangs_and_x (s
, x
, backward_p
)
2915 struct glyph_string
*s
;
2923 x_compute_glyph_string_overhangs (s
);
2933 x_compute_glyph_string_overhangs (s
);
2942 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2943 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2944 assumed to be zero. */
2947 x_get_glyph_overhangs (glyph
, f
, left
, right
)
2948 struct glyph
*glyph
;
2954 if (glyph
->type
== CHAR_GLYPH
)
2958 struct font_info
*font_info
;
2962 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
2964 font_info
= FONT_INFO_FROM_ID (f
, face
->font_info_id
);
2966 && (pcm
= x_per_char_metric (font
, &char2b
)))
2968 if (pcm
->rbearing
> pcm
->width
)
2969 *right
= pcm
->rbearing
- pcm
->width
;
2970 if (pcm
->lbearing
< 0)
2971 *left
= -pcm
->lbearing
;
2977 /* Return the index of the first glyph preceding glyph string S that
2978 is overwritten by S because of S's left overhang. Value is -1
2979 if no glyphs are overwritten. */
2982 x_left_overwritten (s
)
2983 struct glyph_string
*s
;
2987 if (s
->left_overhang
)
2990 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2991 int first
= s
->first_glyph
- glyphs
;
2993 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
2994 x
-= glyphs
[i
].pixel_width
;
3005 /* Return the index of the first glyph preceding glyph string S that
3006 is overwriting S because of its right overhang. Value is -1 if no
3007 glyph in front of S overwrites S. */
3010 x_left_overwriting (s
)
3011 struct glyph_string
*s
;
3014 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3015 int first
= s
->first_glyph
- glyphs
;
3019 for (i
= first
- 1; i
>= 0; --i
)
3022 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3025 x
-= glyphs
[i
].pixel_width
;
3032 /* Return the index of the last glyph following glyph string S that is
3033 not overwritten by S because of S's right overhang. Value is -1 if
3034 no such glyph is found. */
3037 x_right_overwritten (s
)
3038 struct glyph_string
*s
;
3042 if (s
->right_overhang
)
3045 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3046 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3047 int end
= s
->row
->used
[s
->area
];
3049 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3050 x
+= glyphs
[i
].pixel_width
;
3059 /* Return the index of the last glyph following glyph string S that
3060 overwrites S because of its left overhang. Value is negative
3061 if no such glyph is found. */
3064 x_right_overwriting (s
)
3065 struct glyph_string
*s
;
3068 int end
= s
->row
->used
[s
->area
];
3069 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3070 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3074 for (i
= first
; i
< end
; ++i
)
3077 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3080 x
+= glyphs
[i
].pixel_width
;
3087 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3090 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3091 struct glyph_string
*s
;
3095 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
3096 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3097 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3098 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3102 /* Draw the background of glyph_string S. If S->background_filled_p
3103 is non-zero don't draw it. FORCE_P non-zero means draw the
3104 background even if it wouldn't be drawn normally. This is used
3105 when a string preceding S draws into the background of S, or S
3106 contains the first component of a composition. */
3109 x_draw_glyph_string_background (s
, force_p
)
3110 struct glyph_string
*s
;
3113 /* Nothing to do if background has already been drawn or if it
3114 shouldn't be drawn in the first place. */
3115 if (!s
->background_filled_p
)
3117 int box_line_width
= max (s
->face
->box_line_width
, 0);
3121 /* Fill background with a stipple pattern. */
3122 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3123 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3124 s
->y
+ box_line_width
,
3125 s
->background_width
,
3126 s
->height
- 2 * box_line_width
);
3127 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3128 s
->background_filled_p
= 1;
3130 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
3131 || s
->font_not_found_p
3132 || s
->extends_to_end_of_line_p
3135 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
3136 s
->background_width
,
3137 s
->height
- 2 * box_line_width
);
3138 s
->background_filled_p
= 1;
3144 /* Draw the foreground of glyph string S. */
3147 x_draw_glyph_string_foreground (s
)
3148 struct glyph_string
*s
;
3152 /* If first glyph of S has a left box line, start drawing the text
3153 of S to the right of that box line. */
3154 if (s
->face
->box
!= FACE_NO_BOX
3155 && s
->first_glyph
->left_box_line_p
)
3156 x
= s
->x
+ abs (s
->face
->box_line_width
);
3160 /* Draw characters of S as rectangles if S's font could not be
3162 if (s
->font_not_found_p
)
3164 for (i
= 0; i
< s
->nchars
; ++i
)
3166 struct glyph
*g
= s
->first_glyph
+ i
;
3167 XDrawRectangle (s
->display
, s
->window
,
3168 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3170 x
+= g
->pixel_width
;
3175 char *char1b
= (char *) s
->char2b
;
3176 int boff
= s
->font_info
->baseline_offset
;
3178 if (s
->font_info
->vertical_centering
)
3179 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3181 /* If we can use 8-bit functions, condense S->char2b. */
3183 for (i
= 0; i
< s
->nchars
; ++i
)
3184 char1b
[i
] = s
->char2b
[i
].byte2
;
3186 /* Draw text with XDrawString if background has already been
3187 filled. Otherwise, use XDrawImageString. (Note that
3188 XDrawImageString is usually faster than XDrawString.) Always
3189 use XDrawImageString when drawing the cursor so that there is
3190 no chance that characters under a box cursor are invisible. */
3191 if (s
->for_overlaps_p
3192 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3194 /* Draw characters with 16-bit or 8-bit functions. */
3196 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
3197 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3199 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
3200 s
->ybase
- boff
, char1b
, s
->nchars
);
3205 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
3206 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3208 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
3209 s
->ybase
- boff
, char1b
, s
->nchars
);
3214 /* Draw the foreground of composite glyph string S. */
3217 x_draw_composite_glyph_string_foreground (s
)
3218 struct glyph_string
*s
;
3222 /* If first glyph of S has a left box line, start drawing the text
3223 of S to the right of that box line. */
3224 if (s
->face
->box
!= FACE_NO_BOX
3225 && s
->first_glyph
->left_box_line_p
)
3226 x
= s
->x
+ abs (s
->face
->box_line_width
);
3230 /* S is a glyph string for a composition. S->gidx is the index of
3231 the first character drawn for glyphs of this composition.
3232 S->gidx == 0 means we are drawing the very first character of
3233 this composition. */
3235 /* Draw a rectangle for the composition if the font for the very
3236 first character of the composition could not be loaded. */
3237 if (s
->font_not_found_p
)
3240 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
3241 s
->width
- 1, s
->height
- 1);
3245 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3246 XDrawString16 (s
->display
, s
->window
, s
->gc
,
3247 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3248 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3254 #ifdef USE_X_TOOLKIT
3256 static struct frame
*x_frame_of_widget
P_ ((Widget
));
3257 static Boolean cvt_string_to_pixel
P_ ((Display
*, XrmValue
*, Cardinal
*,
3258 XrmValue
*, XrmValue
*, XtPointer
*));
3259 static void cvt_pixel_dtor
P_ ((XtAppContext
, XrmValue
*, XtPointer
,
3260 XrmValue
*, Cardinal
*));
3263 /* Return the frame on which widget WIDGET is used.. Abort if frame
3264 cannot be determined. */
3266 static struct frame
*
3267 x_frame_of_widget (widget
)
3270 struct x_display_info
*dpyinfo
;
3274 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3276 /* Find the top-level shell of the widget. Note that this function
3277 can be called when the widget is not yet realized, so XtWindow
3278 (widget) == 0. That's the reason we can't simply use
3279 x_any_window_to_frame. */
3280 while (!XtIsTopLevelShell (widget
))
3281 widget
= XtParent (widget
);
3283 /* Look for a frame with that top-level widget. Allocate the color
3284 on that frame to get the right gamma correction value. */
3285 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3286 if (GC_FRAMEP (XCAR (tail
))
3287 && (f
= XFRAME (XCAR (tail
)),
3288 (f
->output_data
.nothing
!= 1
3289 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3290 && f
->output_data
.x
->widget
== widget
)
3297 /* Allocate the color COLOR->pixel on the screen and display of
3298 widget WIDGET in colormap CMAP. If an exact match cannot be
3299 allocated, try the nearest color available. Value is non-zero
3300 if successful. This is called from lwlib. */
3303 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3308 struct frame
*f
= x_frame_of_widget (widget
);
3309 return x_alloc_nearest_color (f
, cmap
, color
);
3313 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3314 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3315 If this produces the same color as PIXEL, try a color where all RGB
3316 values have DELTA added. Return the allocated color in *PIXEL.
3317 DISPLAY is the X display, CMAP is the colormap to operate on.
3318 Value is non-zero if successful. */
3321 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
3325 unsigned long *pixel
;
3329 struct frame
*f
= x_frame_of_widget (widget
);
3330 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
3334 /* Structure specifying which arguments should be passed by Xt to
3335 cvt_string_to_pixel. We want the widget's screen and colormap. */
3337 static XtConvertArgRec cvt_string_to_pixel_args
[] =
3339 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
3341 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
3346 /* The address of this variable is returned by
3347 cvt_string_to_pixel. */
3349 static Pixel cvt_string_to_pixel_value
;
3352 /* Convert a color name to a pixel color.
3354 DPY is the display we are working on.
3356 ARGS is an array of *NARGS XrmValue structures holding additional
3357 information about the widget for which the conversion takes place.
3358 The contents of this array are determined by the specification
3359 in cvt_string_to_pixel_args.
3361 FROM is a pointer to an XrmValue which points to the color name to
3362 convert. TO is an XrmValue in which to return the pixel color.
3364 CLOSURE_RET is a pointer to user-data, in which we record if
3365 we allocated the color or not.
3367 Value is True if successful, False otherwise. */
3370 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
3374 XrmValue
*from
, *to
;
3375 XtPointer
*closure_ret
;
3385 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
3386 "wrongParameters", "cvt_string_to_pixel",
3388 "Screen and colormap args required", NULL
, NULL
);
3392 screen
= *(Screen
**) args
[0].addr
;
3393 cmap
= *(Colormap
*) args
[1].addr
;
3394 color_name
= (String
) from
->addr
;
3396 if (strcmp (color_name
, XtDefaultBackground
) == 0)
3398 *closure_ret
= (XtPointer
) False
;
3399 pixel
= WhitePixelOfScreen (screen
);
3401 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
3403 *closure_ret
= (XtPointer
) False
;
3404 pixel
= BlackPixelOfScreen (screen
);
3406 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
3407 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
3409 pixel
= color
.pixel
;
3410 *closure_ret
= (XtPointer
) True
;
3415 Cardinal nparams
= 1;
3417 params
[0] = color_name
;
3418 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
3419 "badValue", "cvt_string_to_pixel",
3420 "XtToolkitError", "Invalid color `%s'",
3425 if (to
->addr
!= NULL
)
3427 if (to
->size
< sizeof (Pixel
))
3429 to
->size
= sizeof (Pixel
);
3433 *(Pixel
*) to
->addr
= pixel
;
3437 cvt_string_to_pixel_value
= pixel
;
3438 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
3441 to
->size
= sizeof (Pixel
);
3446 /* Free a pixel color which was previously allocated via
3447 cvt_string_to_pixel. This is registered as the destructor
3448 for this type of resource via XtSetTypeConverter.
3450 APP is the application context in which we work.
3452 TO is a pointer to an XrmValue holding the color to free.
3453 CLOSURE is the value we stored in CLOSURE_RET for this color
3454 in cvt_string_to_pixel.
3456 ARGS and NARGS are like for cvt_string_to_pixel. */
3459 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
3468 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
3470 "Screen and colormap arguments required",
3473 else if (closure
!= NULL
)
3475 /* We did allocate the pixel, so free it. */
3476 Screen
*screen
= *(Screen
**) args
[0].addr
;
3477 Colormap cmap
= *(Colormap
*) args
[1].addr
;
3478 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
3479 (Pixel
*) to
->addr
, 1);
3484 #endif /* USE_X_TOOLKIT */
3487 /* Value is an array of XColor structures for the contents of the
3488 color map of display DPY. Set *NCELLS to the size of the array.
3489 Note that this probably shouldn't be called for large color maps,
3490 say a 24-bit TrueColor map. */
3492 static const XColor
*
3493 x_color_cells (dpy
, ncells
)
3497 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
3499 if (dpyinfo
->color_cells
== NULL
)
3501 Screen
*screen
= dpyinfo
->screen
;
3504 dpyinfo
->ncolor_cells
3505 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
3506 dpyinfo
->color_cells
3507 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
3508 * sizeof *dpyinfo
->color_cells
);
3510 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
3511 dpyinfo
->color_cells
[i
].pixel
= i
;
3513 XQueryColors (dpy
, dpyinfo
->cmap
,
3514 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
3517 *ncells
= dpyinfo
->ncolor_cells
;
3518 return dpyinfo
->color_cells
;
3522 /* On frame F, translate pixel colors to RGB values for the NCOLORS
3523 colors in COLORS. Use cached information, if available. */
3526 x_query_colors (f
, colors
, ncolors
)
3531 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3533 if (dpyinfo
->color_cells
)
3536 for (i
= 0; i
< ncolors
; ++i
)
3538 unsigned long pixel
= colors
[i
].pixel
;
3539 xassert (pixel
< dpyinfo
->ncolor_cells
);
3540 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
3541 colors
[i
] = dpyinfo
->color_cells
[pixel
];
3545 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
3549 /* On frame F, translate pixel color to RGB values for the color in
3550 COLOR. Use cached information, if available. */
3553 x_query_color (f
, color
)
3557 x_query_colors (f
, color
, 1);
3561 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
3562 exact match can't be allocated, try the nearest color available.
3563 Value is non-zero if successful. Set *COLOR to the color
3567 x_alloc_nearest_color_1 (dpy
, cmap
, color
)
3574 rc
= XAllocColor (dpy
, cmap
, color
);
3577 /* If we got to this point, the colormap is full, so we're going
3578 to try to get the next closest color. The algorithm used is
3579 a least-squares matching, which is what X uses for closest
3580 color matching with StaticColor visuals. */
3582 unsigned long nearest_delta
= ~0;
3584 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
3586 for (nearest
= i
= 0; i
< ncells
; ++i
)
3588 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3589 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3590 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3591 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3593 if (delta
< nearest_delta
)
3596 nearest_delta
= delta
;
3600 color
->red
= cells
[nearest
].red
;
3601 color
->green
= cells
[nearest
].green
;
3602 color
->blue
= cells
[nearest
].blue
;
3603 rc
= XAllocColor (dpy
, cmap
, color
);
3607 /* If allocation succeeded, and the allocated pixel color is not
3608 equal to a cached pixel color recorded earlier, there was a
3609 change in the colormap, so clear the color cache. */
3610 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
3611 XColor
*cached_color
;
3613 if (dpyinfo
->color_cells
3614 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
3615 (cached_color
->red
!= color
->red
3616 || cached_color
->blue
!= color
->blue
3617 || cached_color
->green
!= color
->green
)))
3619 xfree (dpyinfo
->color_cells
);
3620 dpyinfo
->color_cells
= NULL
;
3621 dpyinfo
->ncolor_cells
= 0;
3625 #ifdef DEBUG_X_COLORS
3627 register_color (color
->pixel
);
3628 #endif /* DEBUG_X_COLORS */
3634 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
3635 exact match can't be allocated, try the nearest color available.
3636 Value is non-zero if successful. Set *COLOR to the color
3640 x_alloc_nearest_color (f
, cmap
, color
)
3645 gamma_correct (f
, color
);
3646 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
3650 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3651 It's necessary to do this instead of just using PIXEL directly to
3652 get color reference counts right. */
3655 x_copy_color (f
, pixel
)
3657 unsigned long pixel
;
3661 color
.pixel
= pixel
;
3663 x_query_color (f
, &color
);
3664 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3666 #ifdef DEBUG_X_COLORS
3667 register_color (pixel
);
3673 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3674 It's necessary to do this instead of just using PIXEL directly to
3675 get color reference counts right. */
3678 x_copy_dpy_color (dpy
, cmap
, pixel
)
3681 unsigned long pixel
;
3685 color
.pixel
= pixel
;
3687 XQueryColor (dpy
, cmap
, &color
);
3688 XAllocColor (dpy
, cmap
, &color
);
3690 #ifdef DEBUG_X_COLORS
3691 register_color (pixel
);
3697 /* Brightness beyond which a color won't have its highlight brightness
3700 Nominally, highlight colors for `3d' faces are calculated by
3701 brightening an object's color by a constant scale factor, but this
3702 doesn't yield good results for dark colors, so for colors who's
3703 brightness is less than this value (on a scale of 0-65535) have an
3704 use an additional additive factor.
3706 The value here is set so that the default menu-bar/mode-line color
3707 (grey75) will not have its highlights changed at all. */
3708 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
3711 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3712 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3713 If this produces the same color as PIXEL, try a color where all RGB
3714 values have DELTA added. Return the allocated color in *PIXEL.
3715 DISPLAY is the X display, CMAP is the colormap to operate on.
3716 Value is non-zero if successful. */
3719 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
3723 unsigned long *pixel
;
3731 /* Get RGB color values. */
3732 color
.pixel
= *pixel
;
3733 x_query_color (f
, &color
);
3735 /* Change RGB values by specified FACTOR. Avoid overflow! */
3736 xassert (factor
>= 0);
3737 new.red
= min (0xffff, factor
* color
.red
);
3738 new.green
= min (0xffff, factor
* color
.green
);
3739 new.blue
= min (0xffff, factor
* color
.blue
);
3741 /* Calculate brightness of COLOR. */
3742 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
3744 /* We only boost colors that are darker than
3745 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3746 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3747 /* Make an additive adjustment to NEW, because it's dark enough so
3748 that scaling by FACTOR alone isn't enough. */
3750 /* How far below the limit this color is (0 - 1, 1 being darker). */
3751 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3752 /* The additive adjustment. */
3753 int min_delta
= delta
* dimness
* factor
/ 2;
3757 new.red
= max (0, new.red
- min_delta
);
3758 new.green
= max (0, new.green
- min_delta
);
3759 new.blue
= max (0, new.blue
- min_delta
);
3763 new.red
= min (0xffff, min_delta
+ new.red
);
3764 new.green
= min (0xffff, min_delta
+ new.green
);
3765 new.blue
= min (0xffff, min_delta
+ new.blue
);
3769 /* Try to allocate the color. */
3770 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3773 if (new.pixel
== *pixel
)
3775 /* If we end up with the same color as before, try adding
3776 delta to the RGB values. */
3777 x_free_colors (f
, &new.pixel
, 1);
3779 new.red
= min (0xffff, delta
+ color
.red
);
3780 new.green
= min (0xffff, delta
+ color
.green
);
3781 new.blue
= min (0xffff, delta
+ color
.blue
);
3782 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3793 /* Set up the foreground color for drawing relief lines of glyph
3794 string S. RELIEF is a pointer to a struct relief containing the GC
3795 with which lines will be drawn. Use a color that is FACTOR or
3796 DELTA lighter or darker than the relief's background which is found
3797 in S->f->output_data.x->relief_background. If such a color cannot
3798 be allocated, use DEFAULT_PIXEL, instead. */
3801 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3803 struct relief
*relief
;
3806 unsigned long default_pixel
;
3809 struct x_output
*di
= f
->output_data
.x
;
3810 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
3811 unsigned long pixel
;
3812 unsigned long background
= di
->relief_background
;
3813 Colormap cmap
= FRAME_X_COLORMAP (f
);
3814 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3815 Display
*dpy
= FRAME_X_DISPLAY (f
);
3817 xgcv
.graphics_exposures
= False
;
3818 xgcv
.line_width
= 1;
3820 /* Free previously allocated color. The color cell will be reused
3821 when it has been freed as many times as it was allocated, so this
3822 doesn't affect faces using the same colors. */
3824 && relief
->allocated_p
)
3826 x_free_colors (f
, &relief
->pixel
, 1);
3827 relief
->allocated_p
= 0;
3830 /* Allocate new color. */
3831 xgcv
.foreground
= default_pixel
;
3833 if (dpyinfo
->n_planes
!= 1
3834 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
3836 relief
->allocated_p
= 1;
3837 xgcv
.foreground
= relief
->pixel
= pixel
;
3840 if (relief
->gc
== 0)
3842 xgcv
.stipple
= dpyinfo
->gray
;
3844 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
3847 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
3851 /* Set up colors for the relief lines around glyph string S. */
3854 x_setup_relief_colors (s
)
3855 struct glyph_string
*s
;
3857 struct x_output
*di
= s
->f
->output_data
.x
;
3858 unsigned long color
;
3860 if (s
->face
->use_box_color_for_shadows_p
)
3861 color
= s
->face
->box_color
;
3862 else if (s
->first_glyph
->type
== IMAGE_GLYPH
3864 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
3865 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
3870 /* Get the background color of the face. */
3871 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3872 color
= xgcv
.background
;
3875 if (di
->white_relief
.gc
== 0
3876 || color
!= di
->relief_background
)
3878 di
->relief_background
= color
;
3879 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3880 WHITE_PIX_DEFAULT (s
->f
));
3881 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3882 BLACK_PIX_DEFAULT (s
->f
));
3887 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3888 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3889 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3890 relief. LEFT_P non-zero means draw a relief on the left side of
3891 the rectangle. RIGHT_P non-zero means draw a relief on the right
3892 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3896 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3897 raised_p
, left_p
, right_p
, clip_rect
)
3899 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3900 XRectangle
*clip_rect
;
3902 Display
*dpy
= FRAME_X_DISPLAY (f
);
3903 Window window
= FRAME_X_WINDOW (f
);
3908 gc
= f
->output_data
.x
->white_relief
.gc
;
3910 gc
= f
->output_data
.x
->black_relief
.gc
;
3911 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
3914 for (i
= 0; i
< width
; ++i
)
3915 XDrawLine (dpy
, window
, gc
,
3916 left_x
+ i
* left_p
, top_y
+ i
,
3917 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3921 for (i
= 0; i
< width
; ++i
)
3922 XDrawLine (dpy
, window
, gc
,
3923 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
3925 XSetClipMask (dpy
, gc
, None
);
3927 gc
= f
->output_data
.x
->black_relief
.gc
;
3929 gc
= f
->output_data
.x
->white_relief
.gc
;
3930 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
3933 for (i
= 0; i
< width
; ++i
)
3934 XDrawLine (dpy
, window
, gc
,
3935 left_x
+ i
* left_p
, bottom_y
- i
,
3936 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3940 for (i
= 0; i
< width
; ++i
)
3941 XDrawLine (dpy
, window
, gc
,
3942 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3944 XSetClipMask (dpy
, gc
, None
);
3948 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3949 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3950 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3951 left side of the rectangle. RIGHT_P non-zero means draw a line
3952 on the right side of the rectangle. CLIP_RECT is the clipping
3953 rectangle to use when drawing. */
3956 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3957 left_p
, right_p
, clip_rect
)
3958 struct glyph_string
*s
;
3959 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
;
3960 XRectangle
*clip_rect
;
3964 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3965 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3966 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
3969 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3970 left_x
, top_y
, right_x
- left_x
+ 1, width
);
3974 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3975 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
3978 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3979 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
3983 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3984 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
3986 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3987 XSetClipMask (s
->display
, s
->gc
, None
);
3991 /* Draw a box around glyph string S. */
3994 x_draw_glyph_string_box (s
)
3995 struct glyph_string
*s
;
3997 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3998 int left_p
, right_p
;
3999 struct glyph
*last_glyph
;
4000 XRectangle clip_rect
;
4002 last_x
= window_box_right (s
->w
, s
->area
);
4003 if (s
->row
->full_width_p
4004 && !s
->w
->pseudo_window_p
)
4006 last_x
+= FRAME_X_RIGHT_FRINGE_WIDTH (s
->f
);
4007 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
4008 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
4011 /* The glyph that may have a right box line. */
4012 last_glyph
= (s
->cmp
|| s
->img
4014 : s
->first_glyph
+ s
->nchars
- 1);
4016 width
= abs (s
->face
->box_line_width
);
4017 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
4019 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
4021 : min (last_x
, s
->x
+ s
->background_width
) - 1);
4023 bottom_y
= top_y
+ s
->height
- 1;
4025 left_p
= (s
->first_glyph
->left_box_line_p
4026 || (s
->hl
== DRAW_MOUSE_FACE
4028 || s
->prev
->hl
!= s
->hl
)));
4029 right_p
= (last_glyph
->right_box_line_p
4030 || (s
->hl
== DRAW_MOUSE_FACE
4032 || s
->next
->hl
!= s
->hl
)));
4034 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4036 if (s
->face
->box
== FACE_SIMPLE_BOX
)
4037 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
4038 left_p
, right_p
, &clip_rect
);
4041 x_setup_relief_colors (s
);
4042 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
4043 width
, raised_p
, left_p
, right_p
, &clip_rect
);
4048 /* Draw foreground of image glyph string S. */
4051 x_draw_image_foreground (s
)
4052 struct glyph_string
*s
;
4055 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
4057 /* If first glyph of S has a left box line, start drawing it to the
4058 right of that line. */
4059 if (s
->face
->box
!= FACE_NO_BOX
4060 && s
->first_glyph
->left_box_line_p
)
4061 x
= s
->x
+ abs (s
->face
->box_line_width
);
4065 /* If there is a margin around the image, adjust x- and y-position
4067 x
+= s
->img
->hmargin
;
4068 y
+= s
->img
->vmargin
;
4074 /* We can't set both a clip mask and use XSetClipRectangles
4075 because the latter also sets a clip mask. We also can't
4076 trust on the shape extension to be available
4077 (XShapeCombineRegion). So, compute the rectangle to draw
4079 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4082 XRectangle clip_rect
, image_rect
, r
;
4084 xgcv
.clip_mask
= s
->img
->mask
;
4085 xgcv
.clip_x_origin
= x
;
4086 xgcv
.clip_y_origin
= y
;
4087 xgcv
.function
= GXcopy
;
4088 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4090 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4093 image_rect
.width
= s
->img
->width
;
4094 image_rect
.height
= s
->img
->height
;
4095 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
4096 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
4097 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
4101 XRectangle clip_rect
, image_rect
, r
;
4103 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4106 image_rect
.width
= s
->img
->width
;
4107 image_rect
.height
= s
->img
->height
;
4108 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
4109 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
4110 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
4112 /* When the image has a mask, we can expect that at
4113 least part of a mouse highlight or a block cursor will
4114 be visible. If the image doesn't have a mask, make
4115 a block cursor visible by drawing a rectangle around
4116 the image. I believe it's looking better if we do
4117 nothing here for mouse-face. */
4118 if (s
->hl
== DRAW_CURSOR
)
4119 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
4120 s
->img
->width
- 1, s
->img
->height
- 1);
4124 /* Draw a rectangle if image could not be loaded. */
4125 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
4126 s
->img
->width
- 1, s
->img
->height
- 1);
4130 /* Draw a relief around the image glyph string S. */
4133 x_draw_image_relief (s
)
4134 struct glyph_string
*s
;
4136 int x0
, y0
, x1
, y1
, thick
, raised_p
;
4139 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
4141 /* If first glyph of S has a left box line, start drawing it to the
4142 right of that line. */
4143 if (s
->face
->box
!= FACE_NO_BOX
4144 && s
->first_glyph
->left_box_line_p
)
4145 x
= s
->x
+ abs (s
->face
->box_line_width
);
4149 /* If there is a margin around the image, adjust x- and y-position
4151 x
+= s
->img
->hmargin
;
4152 y
+= s
->img
->vmargin
;
4154 if (s
->hl
== DRAW_IMAGE_SUNKEN
4155 || s
->hl
== DRAW_IMAGE_RAISED
)
4157 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
4158 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
4162 thick
= abs (s
->img
->relief
);
4163 raised_p
= s
->img
->relief
> 0;
4168 x1
= x
+ s
->img
->width
+ thick
- 1;
4169 y1
= y
+ s
->img
->height
+ thick
- 1;
4171 x_setup_relief_colors (s
);
4172 x_get_glyph_string_clip_rect (s
, &r
);
4173 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
4177 /* Draw the foreground of image glyph string S to PIXMAP. */
4180 x_draw_image_foreground_1 (s
, pixmap
)
4181 struct glyph_string
*s
;
4185 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
4187 /* If first glyph of S has a left box line, start drawing it to the
4188 right of that line. */
4189 if (s
->face
->box
!= FACE_NO_BOX
4190 && s
->first_glyph
->left_box_line_p
)
4191 x
= abs (s
->face
->box_line_width
);
4195 /* If there is a margin around the image, adjust x- and y-position
4197 x
+= s
->img
->hmargin
;
4198 y
+= s
->img
->vmargin
;
4204 /* We can't set both a clip mask and use XSetClipRectangles
4205 because the latter also sets a clip mask. We also can't
4206 trust on the shape extension to be available
4207 (XShapeCombineRegion). So, compute the rectangle to draw
4209 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4213 xgcv
.clip_mask
= s
->img
->mask
;
4214 xgcv
.clip_x_origin
= x
;
4215 xgcv
.clip_y_origin
= y
;
4216 xgcv
.function
= GXcopy
;
4217 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4219 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4220 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4221 XSetClipMask (s
->display
, s
->gc
, None
);
4225 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4226 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4228 /* When the image has a mask, we can expect that at
4229 least part of a mouse highlight or a block cursor will
4230 be visible. If the image doesn't have a mask, make
4231 a block cursor visible by drawing a rectangle around
4232 the image. I believe it's looking better if we do
4233 nothing here for mouse-face. */
4234 if (s
->hl
== DRAW_CURSOR
)
4235 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
4236 s
->img
->width
- 1, s
->img
->height
- 1);
4240 /* Draw a rectangle if image could not be loaded. */
4241 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
4242 s
->img
->width
- 1, s
->img
->height
- 1);
4246 /* Draw part of the background of glyph string S. X, Y, W, and H
4247 give the rectangle to draw. */
4250 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4251 struct glyph_string
*s
;
4256 /* Fill background with a stipple pattern. */
4257 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4258 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4259 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4262 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4266 /* Draw image glyph string S.
4269 s->x +-------------------------
4272 | +-------------------------
4275 | | +-------------------
4281 x_draw_image_glyph_string (s
)
4282 struct glyph_string
*s
;
4285 int box_line_hwidth
= abs (s
->face
->box_line_width
);
4286 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
4288 Pixmap pixmap
= None
;
4290 height
= s
->height
- 2 * box_line_vwidth
;
4292 /* Fill background with face under the image. Do it only if row is
4293 taller than image or if image has a clip mask to reduce
4295 s
->stippled_p
= s
->face
->stipple
!= 0;
4296 if (height
> s
->img
->height
4300 || s
->img
->pixmap
== 0
4301 || s
->width
!= s
->background_width
)
4303 if (box_line_hwidth
&& s
->first_glyph
->left_box_line_p
)
4304 x
= s
->x
+ box_line_hwidth
;
4308 y
= s
->y
+ box_line_vwidth
;
4312 /* Create a pixmap as large as the glyph string. Fill it
4313 with the background color. Copy the image to it, using
4314 its mask. Copy the temporary pixmap to the display. */
4315 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4316 int depth
= DefaultDepthOfScreen (screen
);
4318 /* Create a pixmap as large as the glyph string. */
4319 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4320 s
->background_width
,
4323 /* Don't clip in the following because we're working on the
4325 XSetClipMask (s
->display
, s
->gc
, None
);
4327 /* Fill the pixmap with the background color/stipple. */
4330 /* Fill background with a stipple pattern. */
4331 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4332 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4333 0, 0, s
->background_width
, s
->height
);
4334 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4339 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4341 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4342 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4343 0, 0, s
->background_width
, s
->height
);
4344 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4348 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4350 s
->background_filled_p
= 1;
4353 /* Draw the foreground. */
4356 x_draw_image_foreground_1 (s
, pixmap
);
4357 x_set_glyph_string_clipping (s
);
4358 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
4359 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
4360 XFreePixmap (s
->display
, pixmap
);
4363 x_draw_image_foreground (s
);
4365 /* If we must draw a relief around the image, do it. */
4367 || s
->hl
== DRAW_IMAGE_RAISED
4368 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4369 x_draw_image_relief (s
);
4373 /* Draw stretch glyph string S. */
4376 x_draw_stretch_glyph_string (s
)
4377 struct glyph_string
*s
;
4379 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4380 s
->stippled_p
= s
->face
->stipple
!= 0;
4382 if (s
->hl
== DRAW_CURSOR
4383 && !x_stretch_cursor_p
)
4385 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4386 as wide as the stretch glyph. */
4387 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4390 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4392 /* Clear rest using the GC of the original non-cursor face. */
4393 if (width
< s
->background_width
)
4395 int x
= s
->x
+ width
, y
= s
->y
;
4396 int w
= s
->background_width
- width
, h
= s
->height
;
4400 if (s
->row
->mouse_face_p
4401 && cursor_in_mouse_face_p (s
->w
))
4403 x_set_mouse_face_gc (s
);
4409 x_get_glyph_string_clip_rect (s
, &r
);
4410 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
4412 if (s
->face
->stipple
)
4414 /* Fill background with a stipple pattern. */
4415 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4416 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4417 XSetFillStyle (s
->display
, gc
, FillSolid
);
4422 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
4423 XSetForeground (s
->display
, gc
, xgcv
.background
);
4424 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4425 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
4429 else if (!s
->background_filled_p
)
4430 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4433 s
->background_filled_p
= 1;
4437 /* Draw glyph string S. */
4440 x_draw_glyph_string (s
)
4441 struct glyph_string
*s
;
4443 int relief_drawn_p
= 0;
4445 /* If S draws into the background of its successor, draw the
4446 background of the successor first so that S can draw into it.
4447 This makes S->next use XDrawString instead of XDrawImageString. */
4448 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4450 xassert (s
->next
->img
== NULL
);
4451 x_set_glyph_string_gc (s
->next
);
4452 x_set_glyph_string_clipping (s
->next
);
4453 x_draw_glyph_string_background (s
->next
, 1);
4456 /* Set up S->gc, set clipping and draw S. */
4457 x_set_glyph_string_gc (s
);
4459 /* Draw relief (if any) in advance for char/composition so that the
4460 glyph string can be drawn over it. */
4461 if (!s
->for_overlaps_p
4462 && s
->face
->box
!= FACE_NO_BOX
4463 && (s
->first_glyph
->type
== CHAR_GLYPH
4464 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
4467 x_set_glyph_string_clipping (s
);
4468 x_draw_glyph_string_background (s
, 1);
4469 x_draw_glyph_string_box (s
);
4470 x_set_glyph_string_clipping (s
);
4474 x_set_glyph_string_clipping (s
);
4476 switch (s
->first_glyph
->type
)
4479 x_draw_image_glyph_string (s
);
4483 x_draw_stretch_glyph_string (s
);
4487 if (s
->for_overlaps_p
)
4488 s
->background_filled_p
= 1;
4490 x_draw_glyph_string_background (s
, 0);
4491 x_draw_glyph_string_foreground (s
);
4494 case COMPOSITE_GLYPH
:
4495 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4496 s
->background_filled_p
= 1;
4498 x_draw_glyph_string_background (s
, 1);
4499 x_draw_composite_glyph_string_foreground (s
);
4506 if (!s
->for_overlaps_p
)
4508 /* Draw underline. */
4509 if (s
->face
->underline_p
)
4511 unsigned long tem
, h
;
4514 /* Get the underline thickness. Default is 1 pixel. */
4515 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
4518 /* Get the underline position. This is the recommended
4519 vertical offset in pixels from the baseline to the top of
4520 the underline. This is a signed value according to the
4521 specs, and its default is
4523 ROUND ((maximum descent) / 2), with
4524 ROUND(x) = floor (x + 0.5) */
4526 if (x_use_underline_position_properties
4527 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
4528 y
= s
->ybase
+ (long) tem
;
4529 else if (s
->face
->font
)
4530 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
4532 y
= s
->y
+ s
->height
- h
;
4534 if (s
->face
->underline_defaulted_p
)
4535 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4536 s
->x
, y
, s
->width
, h
);
4540 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4541 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
4542 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4543 s
->x
, y
, s
->width
, h
);
4544 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4548 /* Draw overline. */
4549 if (s
->face
->overline_p
)
4551 unsigned long dy
= 0, h
= 1;
4553 if (s
->face
->overline_color_defaulted_p
)
4554 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4559 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4560 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4561 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4563 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4567 /* Draw strike-through. */
4568 if (s
->face
->strike_through_p
)
4570 unsigned long h
= 1;
4571 unsigned long dy
= (s
->height
- h
) / 2;
4573 if (s
->face
->strike_through_color_defaulted_p
)
4574 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4579 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4580 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4581 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4583 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4587 /* Draw relief if not yet drawn. */
4588 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
4589 x_draw_glyph_string_box (s
);
4592 /* Reset clipping. */
4593 XSetClipMask (s
->display
, s
->gc
, None
);
4597 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4598 struct face
**, int));
4601 /* Fill glyph string S with composition components specified by S->cmp.
4603 FACES is an array of faces for all components of this composition.
4604 S->gidx is the index of the first component for S.
4605 OVERLAPS_P non-zero means S should draw the foreground only, and
4606 use its physical height for clipping.
4608 Value is the index of a component not in S. */
4611 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4612 struct glyph_string
*s
;
4613 struct face
**faces
;
4620 s
->for_overlaps_p
= overlaps_p
;
4622 s
->face
= faces
[s
->gidx
];
4623 s
->font
= s
->face
->font
;
4624 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4626 /* For all glyphs of this composition, starting at the offset
4627 S->gidx, until we reach the end of the definition or encounter a
4628 glyph that requires the different face, add it to S. */
4630 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4633 /* All glyph strings for the same composition has the same width,
4634 i.e. the width set for the first component of the composition. */
4636 s
->width
= s
->first_glyph
->pixel_width
;
4638 /* If the specified font could not be loaded, use the frame's
4639 default font, but record the fact that we couldn't load it in
4640 the glyph string so that we can draw rectangles for the
4641 characters of the glyph string. */
4642 if (s
->font
== NULL
)
4644 s
->font_not_found_p
= 1;
4645 s
->font
= FRAME_FONT (s
->f
);
4648 /* Adjust base line for subscript/superscript text. */
4649 s
->ybase
+= s
->first_glyph
->voffset
;
4651 xassert (s
->face
&& s
->face
->gc
);
4653 /* This glyph string must always be drawn with 16-bit functions. */
4656 return s
->gidx
+ s
->nchars
;
4660 /* Fill glyph string S from a sequence of character glyphs.
4662 FACE_ID is the face id of the string. START is the index of the
4663 first glyph to consider, END is the index of the last + 1.
4664 OVERLAPS_P non-zero means S should draw the foreground only, and
4665 use its physical height for clipping.
4667 Value is the index of the first glyph not in S. */
4670 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4671 struct glyph_string
*s
;
4673 int start
, end
, overlaps_p
;
4675 struct glyph
*glyph
, *last
;
4677 int glyph_not_available_p
;
4679 xassert (s
->f
== XFRAME (s
->w
->frame
));
4680 xassert (s
->nchars
== 0);
4681 xassert (start
>= 0 && end
> start
);
4683 s
->for_overlaps_p
= overlaps_p
,
4684 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4685 last
= s
->row
->glyphs
[s
->area
] + end
;
4686 voffset
= glyph
->voffset
;
4688 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4691 && glyph
->type
== CHAR_GLYPH
4692 && glyph
->voffset
== voffset
4693 /* Same face id implies same font, nowadays. */
4694 && glyph
->face_id
== face_id
4695 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4699 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4700 s
->char2b
+ s
->nchars
,
4702 s
->two_byte_p
= two_byte_p
;
4704 xassert (s
->nchars
<= end
- start
);
4705 s
->width
+= glyph
->pixel_width
;
4709 s
->font
= s
->face
->font
;
4710 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4712 /* If the specified font could not be loaded, use the frame's font,
4713 but record the fact that we couldn't load it in
4714 S->font_not_found_p so that we can draw rectangles for the
4715 characters of the glyph string. */
4716 if (s
->font
== NULL
|| glyph_not_available_p
)
4718 s
->font_not_found_p
= 1;
4719 s
->font
= FRAME_FONT (s
->f
);
4722 /* Adjust base line for subscript/superscript text. */
4723 s
->ybase
+= voffset
;
4725 xassert (s
->face
&& s
->face
->gc
);
4726 return glyph
- s
->row
->glyphs
[s
->area
];
4730 /* Fill glyph string S from image glyph S->first_glyph. */
4733 x_fill_image_glyph_string (s
)
4734 struct glyph_string
*s
;
4736 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4737 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4739 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4740 s
->font
= s
->face
->font
;
4741 s
->width
= s
->first_glyph
->pixel_width
;
4743 /* Adjust base line for subscript/superscript text. */
4744 s
->ybase
+= s
->first_glyph
->voffset
;
4748 /* Fill glyph string S from a sequence of stretch glyphs.
4750 ROW is the glyph row in which the glyphs are found, AREA is the
4751 area within the row. START is the index of the first glyph to
4752 consider, END is the index of the last + 1.
4754 Value is the index of the first glyph not in S. */
4757 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4758 struct glyph_string
*s
;
4759 struct glyph_row
*row
;
4760 enum glyph_row_area area
;
4763 struct glyph
*glyph
, *last
;
4764 int voffset
, face_id
;
4766 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4768 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4769 last
= s
->row
->glyphs
[s
->area
] + end
;
4770 face_id
= glyph
->face_id
;
4771 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4772 s
->font
= s
->face
->font
;
4773 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4774 s
->width
= glyph
->pixel_width
;
4775 voffset
= glyph
->voffset
;
4779 && glyph
->type
== STRETCH_GLYPH
4780 && glyph
->voffset
== voffset
4781 && glyph
->face_id
== face_id
);
4783 s
->width
+= glyph
->pixel_width
;
4785 /* Adjust base line for subscript/superscript text. */
4786 s
->ybase
+= voffset
;
4788 /* The case that face->gc == 0 is handled when drawing the glyph
4789 string by calling PREPARE_FACE_FOR_DISPLAY. */
4791 return glyph
- s
->row
->glyphs
[s
->area
];
4795 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4796 of XChar2b structures for S; it can't be allocated in
4797 x_init_glyph_string because it must be allocated via `alloca'. W
4798 is the window on which S is drawn. ROW and AREA are the glyph row
4799 and area within the row from which S is constructed. START is the
4800 index of the first glyph structure covered by S. HL is a
4801 face-override for drawing S. */
4804 x_init_glyph_string (s
, char2b
, w
, row
, area
, start
, hl
)
4805 struct glyph_string
*s
;
4808 struct glyph_row
*row
;
4809 enum glyph_row_area area
;
4811 enum draw_glyphs_face hl
;
4813 bzero (s
, sizeof *s
);
4815 s
->f
= XFRAME (w
->frame
);
4816 s
->display
= FRAME_X_DISPLAY (s
->f
);
4817 s
->window
= FRAME_X_WINDOW (s
->f
);
4822 s
->first_glyph
= row
->glyphs
[area
] + start
;
4823 s
->height
= row
->height
;
4824 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4826 /* Display the internal border below the tool-bar window. */
4827 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4828 s
->y
-= s
->f
->output_data
.x
->internal_border_width
;
4830 s
->ybase
= s
->y
+ row
->ascent
;
4834 /* Set background width of glyph string S. START is the index of the
4835 first glyph following S. LAST_X is the right-most x-position + 1
4836 in the drawing area. */
4839 x_set_glyph_string_background_width (s
, start
, last_x
)
4840 struct glyph_string
*s
;
4844 /* If the face of this glyph string has to be drawn to the end of
4845 the drawing area, set S->extends_to_end_of_line_p. */
4846 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4848 if (start
== s
->row
->used
[s
->area
]
4849 && s
->area
== TEXT_AREA
4850 && ((s
->hl
== DRAW_NORMAL_TEXT
4851 && (s
->row
->fill_line_p
4852 || s
->face
->background
!= default_face
->background
4853 || s
->face
->stipple
!= default_face
->stipple
4854 || s
->row
->mouse_face_p
))
4855 || s
->hl
== DRAW_MOUSE_FACE
4856 || ((s
->hl
== DRAW_IMAGE_RAISED
|| s
->hl
== DRAW_IMAGE_SUNKEN
)
4857 && s
->row
->fill_line_p
)))
4858 s
->extends_to_end_of_line_p
= 1;
4860 /* If S extends its face to the end of the line, set its
4861 background_width to the distance to the right edge of the drawing
4863 if (s
->extends_to_end_of_line_p
)
4864 s
->background_width
= last_x
- s
->x
+ 1;
4866 s
->background_width
= s
->width
;
4870 /* Add a glyph string for a stretch glyph to the list of strings
4871 between HEAD and TAIL. START is the index of the stretch glyph in
4872 row area AREA of glyph row ROW. END is the index of the last glyph
4873 in that glyph row area. X is the current output position assigned
4874 to the new glyph string constructed. HL overrides that face of the
4875 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4876 is the right-most x-position of the drawing area. */
4878 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4879 and below -- keep them on one line. */
4880 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4883 s = (struct glyph_string *) alloca (sizeof *s); \
4884 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4885 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4886 x_append_glyph_string (&HEAD, &TAIL, s); \
4892 /* Add a glyph string for an image glyph to the list of strings
4893 between HEAD and TAIL. START is the index of the image glyph in
4894 row area AREA of glyph row ROW. END is the index of the last glyph
4895 in that glyph row area. X is the current output position assigned
4896 to the new glyph string constructed. HL overrides that face of the
4897 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4898 is the right-most x-position of the drawing area. */
4900 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4903 s = (struct glyph_string *) alloca (sizeof *s); \
4904 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4905 x_fill_image_glyph_string (s); \
4906 x_append_glyph_string (&HEAD, &TAIL, s); \
4913 /* Add a glyph string for a sequence of character glyphs to the list
4914 of strings between HEAD and TAIL. START is the index of the first
4915 glyph in row area AREA of glyph row ROW that is part of the new
4916 glyph string. END is the index of the last glyph in that glyph row
4917 area. X is the current output position assigned to the new glyph
4918 string constructed. HL overrides that face of the glyph; e.g. it
4919 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4920 right-most x-position of the drawing area. */
4922 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4928 c = (ROW)->glyphs[AREA][START].u.ch; \
4929 face_id = (ROW)->glyphs[AREA][START].face_id; \
4931 s = (struct glyph_string *) alloca (sizeof *s); \
4932 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4933 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4934 x_append_glyph_string (&HEAD, &TAIL, s); \
4936 START = x_fill_glyph_string (s, face_id, START, END, \
4942 /* Add a glyph string for a composite sequence to the list of strings
4943 between HEAD and TAIL. START is the index of the first glyph in
4944 row area AREA of glyph row ROW that is part of the new glyph
4945 string. END is the index of the last glyph in that glyph row area.
4946 X is the current output position assigned to the new glyph string
4947 constructed. HL overrides that face of the glyph; e.g. it is
4948 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4949 x-position of the drawing area. */
4951 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4953 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4954 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4955 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4956 struct composition *cmp = composition_table[cmp_id]; \
4957 int glyph_len = cmp->glyph_len; \
4959 struct face **faces; \
4960 struct glyph_string *first_s = NULL; \
4963 base_face = base_face->ascii_face; \
4964 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4965 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4966 /* At first, fill in `char2b' and `faces'. */ \
4967 for (n = 0; n < glyph_len; n++) \
4969 int c = COMPOSITION_GLYPH (cmp, n); \
4970 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4971 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4972 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4973 this_face_id, char2b + n, 1, 1); \
4976 /* Make glyph_strings for each glyph sequence that is drawable by \
4977 the same face, and append them to HEAD/TAIL. */ \
4978 for (n = 0; n < cmp->glyph_len;) \
4980 s = (struct glyph_string *) alloca (sizeof *s); \
4981 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
4982 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4990 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4998 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4999 of AREA of glyph row ROW on window W between indices START and END.
5000 HL overrides the face for drawing glyph strings, e.g. it is
5001 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
5002 x-positions of the drawing area.
5004 This is an ugly monster macro construct because we must use alloca
5005 to allocate glyph strings (because x_draw_glyphs can be called
5008 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
5011 HEAD = TAIL = NULL; \
5012 while (START < END) \
5014 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
5015 switch (first_glyph->type) \
5018 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
5019 TAIL, HL, X, LAST_X, \
5023 case COMPOSITE_GLYPH: \
5024 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
5025 HEAD, TAIL, HL, X, LAST_X,\
5029 case STRETCH_GLYPH: \
5030 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
5031 HEAD, TAIL, HL, X, LAST_X); \
5035 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
5036 TAIL, HL, X, LAST_X); \
5043 x_set_glyph_string_background_width (s, START, LAST_X); \
5050 /* Draw glyphs between START and END in AREA of ROW on window W,
5051 starting at x-position X. X is relative to AREA in W. HL is a
5052 face-override with the following meaning:
5054 DRAW_NORMAL_TEXT draw normally
5055 DRAW_CURSOR draw in cursor face
5056 DRAW_MOUSE_FACE draw in mouse face.
5057 DRAW_INVERSE_VIDEO draw in mode line face
5058 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
5059 DRAW_IMAGE_RAISED draw an image with a raised relief around it
5061 If OVERLAPS_P is non-zero, draw only the foreground of characters
5062 and clip to the physical height of ROW.
5064 Value is the x-position reached, relative to AREA of W. */
5067 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, overlaps_p
)
5070 struct glyph_row
*row
;
5071 enum glyph_row_area area
;
5073 enum draw_glyphs_face hl
;
5076 struct glyph_string
*head
, *tail
;
5077 struct glyph_string
*s
;
5078 int last_x
, area_width
;
5082 /* Let's rather be paranoid than getting a SEGV. */
5083 end
= min (end
, row
->used
[area
]);
5084 start
= max (0, start
);
5085 start
= min (end
, start
);
5087 /* Translate X to frame coordinates. Set last_x to the right
5088 end of the drawing area. */
5089 if (row
->full_width_p
)
5091 /* X is relative to the left edge of W, without scroll bars
5093 struct frame
*f
= XFRAME (w
->frame
);
5094 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
5097 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5098 last_x
= window_left_x
+ area_width
;
5100 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5102 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5103 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
5109 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
5110 last_x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
5114 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
5115 area_width
= window_box_width (w
, area
);
5116 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
5119 /* Build a doubly-linked list of glyph_string structures between
5120 head and tail from what we have to draw. Note that the macro
5121 BUILD_GLYPH_STRINGS will modify its start parameter. That's
5122 the reason we use a separate variable `i'. */
5124 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
5127 x_reached
= tail
->x
+ tail
->background_width
;
5131 /* If there are any glyphs with lbearing < 0 or rbearing > width in
5132 the row, redraw some glyphs in front or following the glyph
5133 strings built above. */
5134 if (head
&& !overlaps_p
&& row
->contains_overlapping_glyphs_p
)
5137 struct glyph_string
*h
, *t
;
5139 /* Compute overhangs for all glyph strings. */
5140 for (s
= head
; s
; s
= s
->next
)
5141 x_compute_glyph_string_overhangs (s
);
5143 /* Prepend glyph strings for glyphs in front of the first glyph
5144 string that are overwritten because of the first glyph
5145 string's left overhang. The background of all strings
5146 prepended must be drawn because the first glyph string
5148 i
= x_left_overwritten (head
);
5152 BUILD_GLYPH_STRINGS (w
, row
, area
, j
, start
, h
, t
,
5153 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5156 x_compute_overhangs_and_x (t
, head
->x
, 1);
5157 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5160 /* Prepend glyph strings for glyphs in front of the first glyph
5161 string that overwrite that glyph string because of their
5162 right overhang. For these strings, only the foreground must
5163 be drawn, because it draws over the glyph string at `head'.
5164 The background must not be drawn because this would overwrite
5165 right overhangs of preceding glyphs for which no glyph
5167 i
= x_left_overwriting (head
);
5170 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, start
, h
, t
,
5171 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5173 for (s
= h
; s
; s
= s
->next
)
5174 s
->background_filled_p
= 1;
5175 x_compute_overhangs_and_x (t
, head
->x
, 1);
5176 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5179 /* Append glyphs strings for glyphs following the last glyph
5180 string tail that are overwritten by tail. The background of
5181 these strings has to be drawn because tail's foreground draws
5183 i
= x_right_overwritten (tail
);
5186 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5187 DRAW_NORMAL_TEXT
, x
, last_x
,
5189 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5190 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5193 /* Append glyph strings for glyphs following the last glyph
5194 string tail that overwrite tail. The foreground of such
5195 glyphs has to be drawn because it writes into the background
5196 of tail. The background must not be drawn because it could
5197 paint over the foreground of following glyphs. */
5198 i
= x_right_overwriting (tail
);
5201 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5202 DRAW_NORMAL_TEXT
, x
, last_x
,
5204 for (s
= h
; s
; s
= s
->next
)
5205 s
->background_filled_p
= 1;
5206 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5207 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5211 /* Draw all strings. */
5212 for (s
= head
; s
; s
= s
->next
)
5213 x_draw_glyph_string (s
);
5215 if (area
== TEXT_AREA
5216 && !row
->full_width_p
5217 /* When drawing overlapping rows, only the glyph strings'
5218 foreground is drawn, which doesn't erase a cursor
5222 int x0
= head
? head
->x
: x
;
5223 int x1
= tail
? tail
->x
+ tail
->background_width
: x
;
5225 x0
= FRAME_TO_WINDOW_PIXEL_X (w
, x0
);
5226 x1
= FRAME_TO_WINDOW_PIXEL_X (w
, x1
);
5228 if (XFASTINT (w
->left_margin_width
) != 0)
5230 int left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
5231 x0
-= left_area_width
;
5232 x1
-= left_area_width
;
5235 notice_overwritten_cursor (w
, area
, x0
, x1
,
5236 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
5239 /* Value is the x-position up to which drawn, relative to AREA of W.
5240 This doesn't include parts drawn because of overhangs. */
5241 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
5242 if (!row
->full_width_p
)
5244 if (area
> LEFT_MARGIN_AREA
&& XFASTINT (w
->left_margin_width
) != 0)
5245 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5246 if (area
> TEXT_AREA
)
5247 x_reached
-= window_box_width (w
, TEXT_AREA
);
5254 /* Fix the display of area AREA of overlapping row ROW in window W. */
5257 x_fix_overlapping_area (w
, row
, area
)
5259 struct glyph_row
*row
;
5260 enum glyph_row_area area
;
5266 if (area
== LEFT_MARGIN_AREA
)
5268 else if (area
== TEXT_AREA
)
5269 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5271 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5272 + window_box_width (w
, TEXT_AREA
));
5274 for (i
= 0; i
< row
->used
[area
];)
5276 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
5278 int start
= i
, start_x
= x
;
5282 x
+= row
->glyphs
[area
][i
].pixel_width
;
5285 while (i
< row
->used
[area
]
5286 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5288 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5289 DRAW_NORMAL_TEXT
, 1);
5293 x
+= row
->glyphs
[area
][i
].pixel_width
;
5302 /* Output LEN glyphs starting at START at the nominal cursor position.
5303 Advance the nominal cursor over the text. The global variable
5304 updated_window contains the window being updated, updated_row is
5305 the glyph row being updated, and updated_area is the area of that
5306 row being updated. */
5309 x_write_glyphs (start
, len
)
5310 struct glyph
*start
;
5315 xassert (updated_window
&& updated_row
);
5320 hpos
= start
- updated_row
->glyphs
[updated_area
];
5321 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5322 updated_row
, updated_area
,
5324 DRAW_NORMAL_TEXT
, 0);
5328 /* Advance the output cursor. */
5329 output_cursor
.hpos
+= len
;
5330 output_cursor
.x
= x
;
5334 /* Insert LEN glyphs from START at the nominal cursor position. */
5337 x_insert_glyphs (start
, len
)
5338 struct glyph
*start
;
5343 int line_height
, shift_by_width
, shifted_region_width
;
5344 struct glyph_row
*row
;
5345 struct glyph
*glyph
;
5346 int frame_x
, frame_y
, hpos
;
5348 xassert (updated_window
&& updated_row
);
5351 f
= XFRAME (WINDOW_FRAME (w
));
5353 /* Get the height of the line we are in. */
5355 line_height
= row
->height
;
5357 /* Get the width of the glyphs to insert. */
5359 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5360 shift_by_width
+= glyph
->pixel_width
;
5362 /* Get the width of the region to shift right. */
5363 shifted_region_width
= (window_box_width (w
, updated_area
)
5368 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
5369 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5370 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5371 f
->output_data
.x
->normal_gc
,
5373 shifted_region_width
, line_height
,
5374 frame_x
+ shift_by_width
, frame_y
);
5376 /* Write the glyphs. */
5377 hpos
= start
- row
->glyphs
[updated_area
];
5378 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5379 DRAW_NORMAL_TEXT
, 0);
5381 /* Advance the output cursor. */
5382 output_cursor
.hpos
+= len
;
5383 output_cursor
.x
+= shift_by_width
;
5388 /* Delete N glyphs at the nominal cursor position. Not implemented
5399 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
5400 If they are <= 0, this is probably an error. */
5403 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
5410 xassert (width
> 0 && height
> 0);
5411 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
5415 /* Erase the current text line from the nominal cursor position
5416 (inclusive) to pixel column TO_X (exclusive). The idea is that
5417 everything from TO_X onward is already erased.
5419 TO_X is a pixel position relative to updated_area of
5420 updated_window. TO_X == -1 means clear to the end of this area. */
5423 x_clear_end_of_line (to_x
)
5427 struct window
*w
= updated_window
;
5428 int max_x
, min_y
, max_y
;
5429 int from_x
, from_y
, to_y
;
5431 xassert (updated_window
&& updated_row
);
5432 f
= XFRAME (w
->frame
);
5434 if (updated_row
->full_width_p
)
5436 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5437 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5438 && !w
->pseudo_window_p
)
5439 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5442 max_x
= window_box_width (w
, updated_area
);
5443 max_y
= window_text_bottom_y (w
);
5445 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5446 of window. For TO_X > 0, truncate to end of drawing area. */
5452 to_x
= min (to_x
, max_x
);
5454 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5456 /* Notice if the cursor will be cleared by this operation. */
5457 if (!updated_row
->full_width_p
)
5458 notice_overwritten_cursor (w
, updated_area
,
5459 output_cursor
.x
, -1,
5461 MATRIX_ROW_BOTTOM_Y (updated_row
));
5463 from_x
= output_cursor
.x
;
5465 /* Translate to frame coordinates. */
5466 if (updated_row
->full_width_p
)
5468 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5469 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5473 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5474 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5477 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5478 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5479 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5481 /* Prevent inadvertently clearing to end of the X window. */
5482 if (to_x
> from_x
&& to_y
> from_y
)
5485 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5486 from_x
, from_y
, to_x
- from_x
, to_y
- from_y
,
5493 /* Clear entire frame. If updating_frame is non-null, clear that
5494 frame. Otherwise clear the selected frame. */
5504 f
= SELECTED_FRAME ();
5506 /* Clearing the frame will erase any cursor, so mark them all as no
5508 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5509 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5510 output_cursor
.x
= -1;
5512 /* We don't set the output cursor here because there will always
5513 follow an explicit cursor_to. */
5515 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5517 /* We have to clear the scroll bars, too. If we have changed
5518 colors or something like that, then they should be notified. */
5519 x_scroll_bar_clear (f
);
5521 XFlush (FRAME_X_DISPLAY (f
));
5527 /* Invert the middle quarter of the frame for .15 sec. */
5529 /* We use the select system call to do the waiting, so we have to make
5530 sure it's available. If it isn't, we just won't do visual bells. */
5532 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5535 /* Subtract the `struct timeval' values X and Y, storing the result in
5536 *RESULT. Return 1 if the difference is negative, otherwise 0. */
5539 timeval_subtract (result
, x
, y
)
5540 struct timeval
*result
, x
, y
;
5542 /* Perform the carry for the later subtraction by updating y. This
5543 is safer because on some systems the tv_sec member is unsigned. */
5544 if (x
.tv_usec
< y
.tv_usec
)
5546 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
5547 y
.tv_usec
-= 1000000 * nsec
;
5551 if (x
.tv_usec
- y
.tv_usec
> 1000000)
5553 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
5554 y
.tv_usec
+= 1000000 * nsec
;
5558 /* Compute the time remaining to wait. tv_usec is certainly
5560 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
5561 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
5563 /* Return indication of whether the result should be considered
5565 return x
.tv_sec
< y
.tv_sec
;
5577 /* Create a GC that will use the GXxor function to flip foreground
5578 pixels into background pixels. */
5582 values
.function
= GXxor
;
5583 values
.foreground
= (f
->output_data
.x
->foreground_pixel
5584 ^ f
->output_data
.x
->background_pixel
);
5586 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5587 GCFunction
| GCForeground
, &values
);
5591 /* Get the height not including a menu bar widget. */
5592 int height
= CHAR_TO_PIXEL_HEIGHT (f
, FRAME_HEIGHT (f
));
5593 /* Height of each line to flash. */
5594 int flash_height
= FRAME_LINE_HEIGHT (f
);
5595 /* These will be the left and right margins of the rectangles. */
5596 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
5597 int flash_right
= PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
5601 /* Don't flash the area between a scroll bar and the frame
5602 edge it is next to. */
5603 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
5605 case vertical_scroll_bar_left
:
5606 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5609 case vertical_scroll_bar_right
:
5610 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5617 width
= flash_right
- flash_left
;
5619 /* If window is tall, flash top and bottom line. */
5620 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5622 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5624 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5625 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5626 width
, flash_height
);
5627 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5629 (height
- flash_height
5630 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5631 width
, flash_height
);
5634 /* If it is short, flash it all. */
5635 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5636 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5637 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5642 struct timeval wakeup
;
5644 EMACS_GET_TIME (wakeup
);
5646 /* Compute time to wait until, propagating carry from usecs. */
5647 wakeup
.tv_usec
+= 150000;
5648 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
5649 wakeup
.tv_usec
%= 1000000;
5651 /* Keep waiting until past the time wakeup or any input gets
5653 while (! detect_input_pending ())
5655 struct timeval current
;
5656 struct timeval timeout
;
5658 EMACS_GET_TIME (current
);
5660 /* Break if result would be negative. */
5661 if (timeval_subtract (¤t
, wakeup
, current
))
5664 /* How long `select' should wait. */
5666 timeout
.tv_usec
= 10000;
5668 /* Try to wait that long--but we might wake up sooner. */
5669 select (0, NULL
, NULL
, NULL
, &timeout
);
5673 /* If window is tall, flash top and bottom line. */
5674 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5676 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5678 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5679 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5680 width
, flash_height
);
5681 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5683 (height
- flash_height
5684 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5685 width
, flash_height
);
5688 /* If it is short, flash it all. */
5689 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5690 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5691 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5693 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5701 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5704 /* Make audible bell. */
5709 struct frame
*f
= SELECTED_FRAME ();
5711 if (FRAME_X_DISPLAY (f
))
5713 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5720 XBell (FRAME_X_DISPLAY (f
), 0);
5721 XFlush (FRAME_X_DISPLAY (f
));
5728 /* Specify how many text lines, from the top of the window,
5729 should be affected by insert-lines and delete-lines operations.
5730 This, and those operations, are used only within an update
5731 that is bounded by calls to x_update_begin and x_update_end. */
5734 XTset_terminal_window (n
)
5737 /* This function intentionally left blank. */
5742 /***********************************************************************
5744 ***********************************************************************/
5746 /* Perform an insert-lines or delete-lines operation, inserting N
5747 lines or deleting -N lines at vertical position VPOS. */
5750 x_ins_del_lines (vpos
, n
)
5757 /* Scroll part of the display as described by RUN. */
5760 x_scroll_run (w
, run
)
5764 struct frame
*f
= XFRAME (w
->frame
);
5765 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5767 /* Get frame-relative bounding box of the text display area of W,
5768 without mode lines. Include in this box the left and right
5770 window_box (w
, -1, &x
, &y
, &width
, &height
);
5771 width
+= FRAME_X_FRINGE_WIDTH (f
);
5772 x
-= FRAME_X_LEFT_FRINGE_WIDTH (f
);
5774 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5775 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5776 bottom_y
= y
+ height
;
5780 /* Scrolling up. Make sure we don't copy part of the mode
5781 line at the bottom. */
5782 if (from_y
+ run
->height
> bottom_y
)
5783 height
= bottom_y
- from_y
;
5785 height
= run
->height
;
5789 /* Scolling down. Make sure we don't copy over the mode line.
5791 if (to_y
+ run
->height
> bottom_y
)
5792 height
= bottom_y
- to_y
;
5794 height
= run
->height
;
5799 /* Cursor off. Will be switched on again in x_update_window_end. */
5803 XCopyArea (FRAME_X_DISPLAY (f
),
5804 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5805 f
->output_data
.x
->normal_gc
,
5815 /***********************************************************************
5817 ***********************************************************************/
5819 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5820 corner of the exposed rectangle. W and H are width and height of
5821 the exposed area. All are pixel values. W or H zero means redraw
5822 the entire frame. */
5825 expose_frame (f
, x
, y
, w
, h
)
5830 int mouse_face_overwritten_p
= 0;
5832 TRACE ((stderr
, "expose_frame "));
5834 /* No need to redraw if frame will be redrawn soon. */
5835 if (FRAME_GARBAGED_P (f
))
5837 TRACE ((stderr
, " garbaged\n"));
5841 /* If basic faces haven't been realized yet, there is no point in
5842 trying to redraw anything. This can happen when we get an expose
5843 event while Emacs is starting, e.g. by moving another window. */
5844 if (FRAME_FACE_CACHE (f
) == NULL
5845 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5847 TRACE ((stderr
, " no faces\n"));
5851 if (w
== 0 || h
== 0)
5854 r
.width
= CANON_X_UNIT (f
) * f
->width
;
5855 r
.height
= CANON_Y_UNIT (f
) * f
->height
;
5865 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
5866 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
5868 if (WINDOWP (f
->tool_bar_window
))
5869 mouse_face_overwritten_p
5870 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
5872 #ifndef USE_X_TOOLKIT
5873 if (WINDOWP (f
->menu_bar_window
))
5874 mouse_face_overwritten_p
5875 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
5876 #endif /* not USE_X_TOOLKIT */
5878 /* Some window managers support a focus-follows-mouse style with
5879 delayed raising of frames. Imagine a partially obscured frame,
5880 and moving the mouse into partially obscured mouse-face on that
5881 frame. The visible part of the mouse-face will be highlighted,
5882 then the WM raises the obscured frame. With at least one WM, KDE
5883 2.1, Emacs is not getting any event for the raising of the frame
5884 (even tried with SubstructureRedirectMask), only Expose events.
5885 These expose events will draw text normally, i.e. not
5886 highlighted. Which means we must redo the highlight here.
5887 Subsume it under ``we love X''. --gerd 2001-08-15 */
5888 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
5890 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5891 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5893 int x
= dpyinfo
->mouse_face_mouse_x
;
5894 int y
= dpyinfo
->mouse_face_mouse_y
;
5895 clear_mouse_face (dpyinfo
);
5896 note_mouse_highlight (f
, x
, y
);
5902 /* Redraw (parts) of all windows in the window tree rooted at W that
5903 intersect R. R contains frame pixel coordinates. Value is
5904 non-zero if the exposure overwrites mouse-face. */
5907 expose_window_tree (w
, r
)
5911 struct frame
*f
= XFRAME (w
->frame
);
5912 int mouse_face_overwritten_p
= 0;
5914 while (w
&& !FRAME_GARBAGED_P (f
))
5916 if (!NILP (w
->hchild
))
5917 mouse_face_overwritten_p
5918 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
5919 else if (!NILP (w
->vchild
))
5920 mouse_face_overwritten_p
5921 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
5923 mouse_face_overwritten_p
|= expose_window (w
, r
);
5925 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
5928 return mouse_face_overwritten_p
;
5932 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5933 which intersects rectangle R. R is in window-relative coordinates. */
5936 expose_area (w
, row
, r
, area
)
5938 struct glyph_row
*row
;
5940 enum glyph_row_area area
;
5942 struct glyph
*first
= row
->glyphs
[area
];
5943 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5945 int first_x
, start_x
, x
;
5947 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5948 /* If row extends face to end of line write the whole line. */
5949 x_draw_glyphs (w
, 0, row
, area
, 0, row
->used
[area
],
5950 DRAW_NORMAL_TEXT
, 0);
5953 /* Set START_X to the window-relative start position for drawing glyphs of
5954 AREA. The first glyph of the text area can be partially visible.
5955 The first glyphs of other areas cannot. */
5956 if (area
== LEFT_MARGIN_AREA
)
5958 else if (area
== TEXT_AREA
)
5959 start_x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5961 start_x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5962 + window_box_width (w
, TEXT_AREA
));
5965 /* Find the first glyph that must be redrawn. */
5967 && x
+ first
->pixel_width
< r
->x
)
5969 x
+= first
->pixel_width
;
5973 /* Find the last one. */
5977 && x
< r
->x
+ r
->width
)
5979 x
+= last
->pixel_width
;
5985 x_draw_glyphs (w
, first_x
- start_x
, row
, area
,
5986 first
- row
->glyphs
[area
],
5987 last
- row
->glyphs
[area
],
5988 DRAW_NORMAL_TEXT
, 0);
5993 /* Redraw the parts of the glyph row ROW on window W intersecting
5994 rectangle R. R is in window-relative coordinates. Value is
5995 non-zero if mouse-face was overwritten. */
5998 expose_line (w
, row
, r
)
6000 struct glyph_row
*row
;
6003 xassert (row
->enabled_p
);
6005 if (row
->mode_line_p
|| w
->pseudo_window_p
)
6006 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
6007 DRAW_NORMAL_TEXT
, 0);
6010 if (row
->used
[LEFT_MARGIN_AREA
])
6011 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
6012 if (row
->used
[TEXT_AREA
])
6013 expose_area (w
, row
, r
, TEXT_AREA
);
6014 if (row
->used
[RIGHT_MARGIN_AREA
])
6015 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
6016 x_draw_row_fringe_bitmaps (w
, row
);
6019 return row
->mouse_face_p
;
6023 /* Return non-zero if W's cursor intersects rectangle R. */
6026 x_phys_cursor_in_rect_p (w
, r
)
6030 XRectangle cr
, result
;
6031 struct glyph
*cursor_glyph
;
6033 cursor_glyph
= get_phys_cursor_glyph (w
);
6036 cr
.x
= w
->phys_cursor
.x
;
6037 cr
.y
= w
->phys_cursor
.y
;
6038 cr
.width
= cursor_glyph
->pixel_width
;
6039 cr
.height
= w
->phys_cursor_height
;
6040 return x_intersect_rectangles (&cr
, r
, &result
);
6047 /* Redraw the part of window W intersection rectangle FR. Pixel
6048 coordinates in FR are frame-relative. Call this function with
6049 input blocked. Value is non-zero if the exposure overwrites
6053 expose_window (w
, fr
)
6057 struct frame
*f
= XFRAME (w
->frame
);
6059 int mouse_face_overwritten_p
= 0;
6061 /* If window is not yet fully initialized, do nothing. This can
6062 happen when toolkit scroll bars are used and a window is split.
6063 Reconfiguring the scroll bar will generate an expose for a newly
6065 if (w
->current_matrix
== NULL
)
6068 /* When we're currently updating the window, display and current
6069 matrix usually don't agree. Arrange for a thorough display
6071 if (w
== updated_window
)
6073 SET_FRAME_GARBAGED (f
);
6077 /* Frame-relative pixel rectangle of W. */
6078 wr
.x
= XFASTINT (w
->left
) * CANON_X_UNIT (f
);
6079 wr
.y
= XFASTINT (w
->top
) * CANON_Y_UNIT (f
);
6080 wr
.width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
6081 wr
.height
= XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
6083 if (x_intersect_rectangles (fr
, &wr
, &r
))
6085 int yb
= window_text_bottom_y (w
);
6086 struct glyph_row
*row
;
6087 int cursor_cleared_p
;
6089 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
6090 r
.x
, r
.y
, r
.width
, r
.height
));
6092 /* Convert to window coordinates. */
6093 r
.x
= FRAME_TO_WINDOW_PIXEL_X (w
, r
.x
);
6094 r
.y
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
.y
);
6096 /* Turn off the cursor. */
6097 if (!w
->pseudo_window_p
6098 && x_phys_cursor_in_rect_p (w
, &r
))
6101 cursor_cleared_p
= 1;
6104 cursor_cleared_p
= 0;
6106 /* Find the first row intersecting the rectangle R. */
6107 for (row
= w
->current_matrix
->rows
;
6112 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
6114 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
6115 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
6116 || (r
.y
>= y0
&& r
.y
< y1
)
6117 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
6119 if (expose_line (w
, row
, &r
))
6120 mouse_face_overwritten_p
= 1;
6127 /* Display the mode line if there is one. */
6128 if (WINDOW_WANTS_MODELINE_P (w
)
6129 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
6131 && row
->y
< r
.y
+ r
.height
)
6133 if (expose_line (w
, row
, &r
))
6134 mouse_face_overwritten_p
= 1;
6137 if (!w
->pseudo_window_p
)
6139 /* Draw border between windows. */
6140 x_draw_vertical_border (w
);
6142 /* Turn the cursor on again. */
6143 if (cursor_cleared_p
)
6144 x_update_window_cursor (w
, 1);
6148 return mouse_face_overwritten_p
;
6152 /* Determine the intersection of two rectangles R1 and R2. Return
6153 the intersection in *RESULT. Value is non-zero if RESULT is not
6157 x_intersect_rectangles (r1
, r2
, result
)
6158 XRectangle
*r1
, *r2
, *result
;
6160 XRectangle
*left
, *right
;
6161 XRectangle
*upper
, *lower
;
6162 int intersection_p
= 0;
6164 /* Rearrange so that R1 is the left-most rectangle. */
6166 left
= r1
, right
= r2
;
6168 left
= r2
, right
= r1
;
6170 /* X0 of the intersection is right.x0, if this is inside R1,
6171 otherwise there is no intersection. */
6172 if (right
->x
<= left
->x
+ left
->width
)
6174 result
->x
= right
->x
;
6176 /* The right end of the intersection is the minimum of the
6177 the right ends of left and right. */
6178 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
6181 /* Same game for Y. */
6183 upper
= r1
, lower
= r2
;
6185 upper
= r2
, lower
= r1
;
6187 /* The upper end of the intersection is lower.y0, if this is inside
6188 of upper. Otherwise, there is no intersection. */
6189 if (lower
->y
<= upper
->y
+ upper
->height
)
6191 result
->y
= lower
->y
;
6193 /* The lower end of the intersection is the minimum of the lower
6194 ends of upper and lower. */
6195 result
->height
= (min (lower
->y
+ lower
->height
,
6196 upper
->y
+ upper
->height
)
6202 return intersection_p
;
6213 /* We used to only do this if Vx_no_window_manager was non-nil, but
6214 the ICCCM (section 4.1.6) says that the window's border pixmap
6215 and border pixel are window attributes which are "private to the
6216 client", so we can always change it to whatever we want. */
6218 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6219 f
->output_data
.x
->border_pixel
);
6221 x_update_cursor (f
, 1);
6225 frame_unhighlight (f
)
6228 /* We used to only do this if Vx_no_window_manager was non-nil, but
6229 the ICCCM (section 4.1.6) says that the window's border pixmap
6230 and border pixel are window attributes which are "private to the
6231 client", so we can always change it to whatever we want. */
6233 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6234 f
->output_data
.x
->border_tile
);
6236 x_update_cursor (f
, 1);
6239 /* The focus has changed. Update the frames as necessary to reflect
6240 the new situation. Note that we can't change the selected frame
6241 here, because the Lisp code we are interrupting might become confused.
6242 Each event gets marked with the frame in which it occurred, so the
6243 Lisp code can tell when the switch took place by examining the events. */
6246 x_new_focus_frame (dpyinfo
, frame
)
6247 struct x_display_info
*dpyinfo
;
6248 struct frame
*frame
;
6250 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
6252 if (frame
!= dpyinfo
->x_focus_frame
)
6254 /* Set this before calling other routines, so that they see
6255 the correct value of x_focus_frame. */
6256 dpyinfo
->x_focus_frame
= frame
;
6258 if (old_focus
&& old_focus
->auto_lower
)
6259 x_lower_frame (old_focus
);
6262 selected_frame
= frame
;
6263 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
6265 Fselect_window (selected_frame
->selected_window
);
6266 choose_minibuf_frame ();
6269 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
6270 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
6272 pending_autoraise_frame
= 0;
6275 x_frame_rehighlight (dpyinfo
);
6278 /* Handle an event saying the mouse has moved out of an Emacs frame. */
6281 x_mouse_leave (dpyinfo
)
6282 struct x_display_info
*dpyinfo
;
6284 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
6287 /* The focus has changed, or we have redirected a frame's focus to
6288 another frame (this happens when a frame uses a surrogate
6289 mini-buffer frame). Shift the highlight as appropriate.
6291 The FRAME argument doesn't necessarily have anything to do with which
6292 frame is being highlighted or un-highlighted; we only use it to find
6293 the appropriate X display info. */
6296 XTframe_rehighlight (frame
)
6297 struct frame
*frame
;
6299 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
6303 x_frame_rehighlight (dpyinfo
)
6304 struct x_display_info
*dpyinfo
;
6306 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
6308 if (dpyinfo
->x_focus_frame
)
6310 dpyinfo
->x_highlight_frame
6311 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
6312 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
6313 : dpyinfo
->x_focus_frame
);
6314 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
6316 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
6317 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
6321 dpyinfo
->x_highlight_frame
= 0;
6323 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
6326 frame_unhighlight (old_highlight
);
6327 if (dpyinfo
->x_highlight_frame
)
6328 frame_highlight (dpyinfo
->x_highlight_frame
);
6334 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
6336 /* Initialize mode_switch_bit and modifier_meaning. */
6338 x_find_modifier_meanings (dpyinfo
)
6339 struct x_display_info
*dpyinfo
;
6341 int min_code
, max_code
;
6344 XModifierKeymap
*mods
;
6346 dpyinfo
->meta_mod_mask
= 0;
6347 dpyinfo
->shift_lock_mask
= 0;
6348 dpyinfo
->alt_mod_mask
= 0;
6349 dpyinfo
->super_mod_mask
= 0;
6350 dpyinfo
->hyper_mod_mask
= 0;
6353 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
6355 min_code
= dpyinfo
->display
->min_keycode
;
6356 max_code
= dpyinfo
->display
->max_keycode
;
6359 syms
= XGetKeyboardMapping (dpyinfo
->display
,
6360 min_code
, max_code
- min_code
+ 1,
6362 mods
= XGetModifierMapping (dpyinfo
->display
);
6364 /* Scan the modifier table to see which modifier bits the Meta and
6365 Alt keysyms are on. */
6367 int row
, col
; /* The row and column in the modifier table. */
6369 for (row
= 3; row
< 8; row
++)
6370 for (col
= 0; col
< mods
->max_keypermod
; col
++)
6373 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
6375 /* Zeroes are used for filler. Skip them. */
6379 /* Are any of this keycode's keysyms a meta key? */
6383 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
6385 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
6391 dpyinfo
->meta_mod_mask
|= (1 << row
);
6396 dpyinfo
->alt_mod_mask
|= (1 << row
);
6401 dpyinfo
->hyper_mod_mask
|= (1 << row
);
6406 dpyinfo
->super_mod_mask
|= (1 << row
);
6410 /* Ignore this if it's not on the lock modifier. */
6411 if ((1 << row
) == LockMask
)
6412 dpyinfo
->shift_lock_mask
= LockMask
;
6420 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
6421 if (! dpyinfo
->meta_mod_mask
)
6423 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
6424 dpyinfo
->alt_mod_mask
= 0;
6427 /* If some keys are both alt and meta,
6428 make them just meta, not alt. */
6429 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
6431 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
6434 XFree ((char *) syms
);
6435 XFreeModifiermap (mods
);
6438 /* Convert between the modifier bits X uses and the modifier bits
6442 x_x_to_emacs_modifiers (dpyinfo
, state
)
6443 struct x_display_info
*dpyinfo
;
6446 EMACS_UINT mod_meta
= meta_modifier
;
6447 EMACS_UINT mod_alt
= alt_modifier
;
6448 EMACS_UINT mod_hyper
= hyper_modifier
;
6449 EMACS_UINT mod_super
= super_modifier
;
6452 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
6453 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
6454 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
6455 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
6456 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
6457 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
6458 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
6459 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
6462 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
6463 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
6464 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
6465 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
6466 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
6467 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
6471 x_emacs_to_x_modifiers (dpyinfo
, state
)
6472 struct x_display_info
*dpyinfo
;
6475 EMACS_UINT mod_meta
= meta_modifier
;
6476 EMACS_UINT mod_alt
= alt_modifier
;
6477 EMACS_UINT mod_hyper
= hyper_modifier
;
6478 EMACS_UINT mod_super
= super_modifier
;
6482 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
6483 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
6484 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
6485 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
6486 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
6487 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
6488 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
6489 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
6492 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
6493 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
6494 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
6495 | ((state
& shift_modifier
) ? ShiftMask
: 0)
6496 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
6497 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
6500 /* Convert a keysym to its name. */
6503 x_get_keysym_name (keysym
)
6509 value
= XKeysymToString (keysym
);
6517 /* Mouse clicks and mouse movement. Rah. */
6519 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6520 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6521 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6522 not force the value into range. */
6525 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
6527 register int pix_x
, pix_y
;
6528 register int *x
, *y
;
6532 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6533 even for negative values. */
6535 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
6537 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
6539 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
6540 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
6544 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
6545 bounds
->height
= f
->output_data
.x
->line_height
;
6546 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
6547 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
6554 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
6555 pix_x
= FRAME_WINDOW_WIDTH (f
);
6559 else if (pix_y
> f
->height
)
6568 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6569 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6570 can't tell the positions because W's display is not up to date,
6574 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
6577 int *frame_x
, *frame_y
;
6581 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
6582 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
6584 if (display_completed
)
6586 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6587 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
6588 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
6594 *frame_x
+= glyph
->pixel_width
;
6602 *frame_y
= *frame_x
= 0;
6606 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6607 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6612 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6614 If the event is a button press, then note that we have grabbed
6618 construct_mouse_click (result
, event
, f
)
6619 struct input_event
*result
;
6620 XButtonEvent
*event
;
6623 /* Make the event type no_event; we'll change that when we decide
6625 result
->kind
= mouse_click
;
6626 result
->code
= event
->button
- Button1
;
6627 result
->timestamp
= event
->time
;
6628 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6630 | (event
->type
== ButtonRelease
6634 XSETINT (result
->x
, event
->x
);
6635 XSETINT (result
->y
, event
->y
);
6636 XSETFRAME (result
->frame_or_window
, f
);
6642 /* Function to report a mouse movement to the mainstream Emacs code.
6643 The input handler calls this.
6645 We have received a mouse movement event, which is given in *event.
6646 If the mouse is over a different glyph than it was last time, tell
6647 the mainstream emacs code by setting mouse_moved. If not, ask for
6648 another motion event, so we can check again the next time it moves. */
6650 static XMotionEvent last_mouse_motion_event
;
6651 static Lisp_Object last_mouse_motion_frame
;
6654 note_mouse_movement (frame
, event
)
6656 XMotionEvent
*event
;
6658 last_mouse_movement_time
= event
->time
;
6659 last_mouse_motion_event
= *event
;
6660 XSETFRAME (last_mouse_motion_frame
, frame
);
6662 if (event
->window
!= FRAME_X_WINDOW (frame
))
6664 frame
->mouse_moved
= 1;
6665 last_mouse_scroll_bar
= Qnil
;
6666 note_mouse_highlight (frame
, -1, -1);
6669 /* Has the mouse moved off the glyph it was on at the last sighting? */
6670 else if (event
->x
< last_mouse_glyph
.x
6671 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
6672 || event
->y
< last_mouse_glyph
.y
6673 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
6675 frame
->mouse_moved
= 1;
6676 last_mouse_scroll_bar
= Qnil
;
6677 note_mouse_highlight (frame
, event
->x
, event
->y
);
6682 /************************************************************************
6684 ************************************************************************/
6686 /* Find the glyph under window-relative coordinates X/Y in window W.
6687 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6688 strings. Return in *HPOS and *VPOS the row and column number of
6689 the glyph found. Return in *AREA the glyph area containing X.
6690 Value is a pointer to the glyph found or null if X/Y is not on
6691 text, or we can't tell because W's current matrix is not up to
6694 static struct glyph
*
6695 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
, buffer_only_p
)
6698 int *hpos
, *vpos
, *area
;
6701 struct glyph
*glyph
, *end
;
6702 struct glyph_row
*row
= NULL
;
6703 int x0
, i
, left_area_width
;
6705 /* Find row containing Y. Give up if some row is not enabled. */
6706 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6708 row
= MATRIX_ROW (w
->current_matrix
, i
);
6709 if (!row
->enabled_p
)
6711 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6718 /* Give up if Y is not in the window. */
6719 if (i
== w
->current_matrix
->nrows
)
6722 /* Get the glyph area containing X. */
6723 if (w
->pseudo_window_p
)
6730 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6731 if (x
< left_area_width
)
6733 *area
= LEFT_MARGIN_AREA
;
6736 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6739 x0
= row
->x
+ left_area_width
;
6743 *area
= RIGHT_MARGIN_AREA
;
6744 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6748 /* Find glyph containing X. */
6749 glyph
= row
->glyphs
[*area
];
6750 end
= glyph
+ row
->used
[*area
];
6753 if (x
< x0
+ glyph
->pixel_width
)
6755 if (w
->pseudo_window_p
)
6757 else if (!buffer_only_p
|| BUFFERP (glyph
->object
))
6761 x0
+= glyph
->pixel_width
;
6768 *hpos
= glyph
- row
->glyphs
[*area
];
6773 /* Convert frame-relative x/y to coordinates relative to window W.
6774 Takes pseudo-windows into account. */
6777 frame_to_window_pixel_xy (w
, x
, y
)
6781 if (w
->pseudo_window_p
)
6783 /* A pseudo-window is always full-width, and starts at the
6784 left edge of the frame, plus a frame border. */
6785 struct frame
*f
= XFRAME (w
->frame
);
6786 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6787 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6791 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6792 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6797 /* Take proper action when mouse has moved to the mode or header line
6798 or marginal area of window W, x-position X and y-position Y. Area
6799 is 1, 3, 6 or 7 for the mode line, header line, left and right
6800 marginal area respectively. X is relative to the start of the text
6801 display area of W, so the width of bitmap areas and scroll bars
6802 must be subtracted to get a position relative to the start of the
6806 note_mode_line_or_margin_highlight (w
, x
, y
, portion
)
6810 struct frame
*f
= XFRAME (w
->frame
);
6811 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6812 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6814 Lisp_Object string
, help
, map
, pos
;
6816 if (portion
== 1 || portion
== 3)
6817 string
= mode_line_string (w
, x
, y
, portion
== 1, &charpos
);
6819 string
= marginal_area_string (w
, x
, y
, portion
, &charpos
);
6821 if (STRINGP (string
))
6823 pos
= make_number (charpos
);
6825 /* If we're on a string with `help-echo' text property, arrange
6826 for the help to be displayed. This is done by setting the
6827 global variable help_echo to the help string. */
6828 help
= Fget_text_property (pos
, Qhelp_echo
, string
);
6832 XSETWINDOW (help_echo_window
, w
);
6833 help_echo_object
= string
;
6834 help_echo_pos
= charpos
;
6837 /* Change the mouse pointer according to what is under X/Y. */
6838 map
= Fget_text_property (pos
, Qlocal_map
, string
);
6840 map
= Fget_text_property (pos
, Qkeymap
, string
);
6842 cursor
= f
->output_data
.x
->nontext_cursor
;
6845 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6849 /* Take proper action when the mouse has moved to position X, Y on
6850 frame F as regards highlighting characters that have mouse-face
6851 properties. Also de-highlighting chars where the mouse was before.
6852 X and Y can be negative or out of range. */
6855 note_mouse_highlight (f
, x
, y
)
6859 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6863 Cursor cursor
= None
;
6866 /* When a menu is active, don't highlight because this looks odd. */
6867 #ifdef USE_X_TOOLKIT
6868 if (popup_activated ())
6872 if (NILP (Vmouse_highlight
)
6873 || !f
->glyphs_initialized_p
)
6876 dpyinfo
->mouse_face_mouse_x
= x
;
6877 dpyinfo
->mouse_face_mouse_y
= y
;
6878 dpyinfo
->mouse_face_mouse_frame
= f
;
6880 if (dpyinfo
->mouse_face_defer
)
6885 dpyinfo
->mouse_face_deferred_gc
= 1;
6889 /* Which window is that in? */
6890 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6892 /* If we were displaying active text in another window, clear that. */
6893 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6894 clear_mouse_face (dpyinfo
);
6896 /* Not on a window -> return. */
6897 if (!WINDOWP (window
))
6900 /* Convert to window-relative pixel coordinates. */
6901 w
= XWINDOW (window
);
6902 frame_to_window_pixel_xy (w
, &x
, &y
);
6904 /* Handle tool-bar window differently since it doesn't display a
6906 if (EQ (window
, f
->tool_bar_window
))
6908 note_tool_bar_highlight (f
, x
, y
);
6912 /* Mouse is on the mode, header line or margin? */
6913 if (portion
== 1 || portion
== 3 || portion
== 6 || portion
== 7)
6915 note_mode_line_or_margin_highlight (w
, x
, y
, portion
);
6920 cursor
= f
->output_data
.x
->horizontal_drag_cursor
;
6922 cursor
= f
->output_data
.x
->text_cursor
;
6924 /* Are we in a window whose display is up to date?
6925 And verify the buffer's text has not changed. */
6926 b
= XBUFFER (w
->buffer
);
6927 if (/* Within text portion of the window. */
6929 && EQ (w
->window_end_valid
, w
->buffer
)
6930 && XFASTINT (w
->last_modified
) == BUF_MODIFF (b
)
6931 && XFASTINT (w
->last_overlay_modified
) == BUF_OVERLAY_MODIFF (b
))
6933 int hpos
, vpos
, pos
, i
, area
;
6934 struct glyph
*glyph
;
6936 Lisp_Object mouse_face
= Qnil
, overlay
= Qnil
, position
;
6937 Lisp_Object
*overlay_vec
= NULL
;
6939 struct buffer
*obuf
;
6940 int obegv
, ozv
, same_region
;
6942 /* Find the glyph under X/Y. */
6943 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
, 0);
6945 /* Clear mouse face if X/Y not over text. */
6947 || area
!= TEXT_AREA
6948 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6950 if (clear_mouse_face (dpyinfo
))
6955 pos
= glyph
->charpos
;
6956 object
= glyph
->object
;
6957 if (!STRINGP (object
) && !BUFFERP (object
))
6960 /* If we get an out-of-range value, return now; avoid an error. */
6961 if (BUFFERP (object
) && pos
> BUF_Z (b
))
6964 /* Make the window's buffer temporarily current for
6965 overlays_at and compute_char_face. */
6966 obuf
= current_buffer
;
6973 /* Is this char mouse-active or does it have help-echo? */
6974 position
= make_number (pos
);
6976 if (BUFFERP (object
))
6978 /* Put all the overlays we want in a vector in overlay_vec.
6979 Store the length in len. If there are more than 10, make
6980 enough space for all, and try again. */
6982 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6983 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
6984 if (noverlays
> len
)
6987 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6988 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
,0);
6991 /* Sort overlays into increasing priority order. */
6992 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6997 same_region
= (EQ (window
, dpyinfo
->mouse_face_window
)
6998 && vpos
>= dpyinfo
->mouse_face_beg_row
6999 && vpos
<= dpyinfo
->mouse_face_end_row
7000 && (vpos
> dpyinfo
->mouse_face_beg_row
7001 || hpos
>= dpyinfo
->mouse_face_beg_col
)
7002 && (vpos
< dpyinfo
->mouse_face_end_row
7003 || hpos
< dpyinfo
->mouse_face_end_col
7004 || dpyinfo
->mouse_face_past_end
));
7009 /* Check mouse-face highlighting. */
7011 /* If there exists an overlay with mouse-face overlapping
7012 the one we are currently highlighting, we have to
7013 check if we enter the overlapping overlay, and then
7014 highlight only that. */
7015 || (OVERLAYP (dpyinfo
->mouse_face_overlay
)
7016 && mouse_face_overlay_overlaps (dpyinfo
->mouse_face_overlay
)))
7018 /* Find the highest priority overlay that has a mouse-face
7021 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
7023 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
7024 if (!NILP (mouse_face
))
7025 overlay
= overlay_vec
[i
];
7028 /* If we're actually highlighting the same overlay as
7029 before, there's no need to do that again. */
7031 && EQ (overlay
, dpyinfo
->mouse_face_overlay
))
7032 goto check_help_echo
;
7034 dpyinfo
->mouse_face_overlay
= overlay
;
7036 /* Clear the display of the old active region, if any. */
7037 if (clear_mouse_face (dpyinfo
))
7040 /* If no overlay applies, get a text property. */
7042 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
7044 /* Handle the overlay case. */
7045 if (!NILP (overlay
))
7047 /* Find the range of text around this char that
7048 should be active. */
7049 Lisp_Object before
, after
;
7052 before
= Foverlay_start (overlay
);
7053 after
= Foverlay_end (overlay
);
7054 /* Record this as the current active region. */
7055 fast_find_position (w
, XFASTINT (before
),
7056 &dpyinfo
->mouse_face_beg_col
,
7057 &dpyinfo
->mouse_face_beg_row
,
7058 &dpyinfo
->mouse_face_beg_x
,
7059 &dpyinfo
->mouse_face_beg_y
, Qnil
);
7061 dpyinfo
->mouse_face_past_end
7062 = !fast_find_position (w
, XFASTINT (after
),
7063 &dpyinfo
->mouse_face_end_col
,
7064 &dpyinfo
->mouse_face_end_row
,
7065 &dpyinfo
->mouse_face_end_x
,
7066 &dpyinfo
->mouse_face_end_y
, Qnil
);
7067 dpyinfo
->mouse_face_window
= window
;
7068 dpyinfo
->mouse_face_face_id
7069 = face_at_buffer_position (w
, pos
, 0, 0,
7070 &ignore
, pos
+ 1, 1);
7072 /* Display it as active. */
7073 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7076 /* Handle the text property case. */
7077 else if (!NILP (mouse_face
) && BUFFERP (object
))
7079 /* Find the range of text around this char that
7080 should be active. */
7081 Lisp_Object before
, after
, beginning
, end
;
7084 beginning
= Fmarker_position (w
->start
);
7085 end
= make_number (BUF_Z (XBUFFER (object
))
7086 - XFASTINT (w
->window_end_pos
));
7088 = Fprevious_single_property_change (make_number (pos
+ 1),
7092 = Fnext_single_property_change (position
, Qmouse_face
,
7095 /* Record this as the current active region. */
7096 fast_find_position (w
, XFASTINT (before
),
7097 &dpyinfo
->mouse_face_beg_col
,
7098 &dpyinfo
->mouse_face_beg_row
,
7099 &dpyinfo
->mouse_face_beg_x
,
7100 &dpyinfo
->mouse_face_beg_y
, Qnil
);
7101 dpyinfo
->mouse_face_past_end
7102 = !fast_find_position (w
, XFASTINT (after
),
7103 &dpyinfo
->mouse_face_end_col
,
7104 &dpyinfo
->mouse_face_end_row
,
7105 &dpyinfo
->mouse_face_end_x
,
7106 &dpyinfo
->mouse_face_end_y
, Qnil
);
7107 dpyinfo
->mouse_face_window
= window
;
7109 if (BUFFERP (object
))
7110 dpyinfo
->mouse_face_face_id
7111 = face_at_buffer_position (w
, pos
, 0, 0,
7112 &ignore
, pos
+ 1, 1);
7114 /* Display it as active. */
7115 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7118 else if (!NILP (mouse_face
) && STRINGP (object
))
7123 b
= Fprevious_single_property_change (make_number (pos
+ 1),
7126 e
= Fnext_single_property_change (position
, Qmouse_face
,
7129 b
= make_number (0);
7131 e
= make_number (XSTRING (object
)->size
- 1);
7132 fast_find_string_pos (w
, XINT (b
), object
,
7133 &dpyinfo
->mouse_face_beg_col
,
7134 &dpyinfo
->mouse_face_beg_row
,
7135 &dpyinfo
->mouse_face_beg_x
,
7136 &dpyinfo
->mouse_face_beg_y
, 0);
7137 fast_find_string_pos (w
, XINT (e
), object
,
7138 &dpyinfo
->mouse_face_end_col
,
7139 &dpyinfo
->mouse_face_end_row
,
7140 &dpyinfo
->mouse_face_end_x
,
7141 &dpyinfo
->mouse_face_end_y
, 1);
7142 dpyinfo
->mouse_face_past_end
= 0;
7143 dpyinfo
->mouse_face_window
= window
;
7144 dpyinfo
->mouse_face_face_id
7145 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
7147 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7150 else if (STRINGP (object
) && NILP (mouse_face
))
7152 /* A string which doesn't have mouse-face, but
7153 the text ``under'' it might have. */
7154 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
7155 int start
= MATRIX_ROW_START_CHARPOS (r
);
7157 pos
= string_buffer_position (w
, object
, start
);
7159 mouse_face
= get_char_property_and_overlay (make_number (pos
),
7163 if (!NILP (mouse_face
) && !NILP (overlay
))
7165 Lisp_Object before
= Foverlay_start (overlay
);
7166 Lisp_Object after
= Foverlay_end (overlay
);
7169 /* Note that we might not be able to find position
7170 BEFORE in the glyph matrix if the overlay is
7171 entirely covered by a `display' property. In
7172 this case, we overshoot. So let's stop in
7173 the glyph matrix before glyphs for OBJECT. */
7174 fast_find_position (w
, XFASTINT (before
),
7175 &dpyinfo
->mouse_face_beg_col
,
7176 &dpyinfo
->mouse_face_beg_row
,
7177 &dpyinfo
->mouse_face_beg_x
,
7178 &dpyinfo
->mouse_face_beg_y
,
7181 dpyinfo
->mouse_face_past_end
7182 = !fast_find_position (w
, XFASTINT (after
),
7183 &dpyinfo
->mouse_face_end_col
,
7184 &dpyinfo
->mouse_face_end_row
,
7185 &dpyinfo
->mouse_face_end_x
,
7186 &dpyinfo
->mouse_face_end_y
,
7188 dpyinfo
->mouse_face_window
= window
;
7189 dpyinfo
->mouse_face_face_id
7190 = face_at_buffer_position (w
, pos
, 0, 0,
7191 &ignore
, pos
+ 1, 1);
7193 /* Display it as active. */
7194 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7202 /* Look for a `help-echo' property. */
7204 Lisp_Object help
, overlay
;
7206 /* Check overlays first. */
7207 help
= overlay
= Qnil
;
7208 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
7210 overlay
= overlay_vec
[i
];
7211 help
= Foverlay_get (overlay
, Qhelp_echo
);
7217 help_echo_window
= window
;
7218 help_echo_object
= overlay
;
7219 help_echo_pos
= pos
;
7223 Lisp_Object object
= glyph
->object
;
7224 int charpos
= glyph
->charpos
;
7226 /* Try text properties. */
7227 if (STRINGP (object
)
7229 && charpos
< XSTRING (object
)->size
)
7231 help
= Fget_text_property (make_number (charpos
),
7232 Qhelp_echo
, object
);
7235 /* If the string itself doesn't specify a help-echo,
7236 see if the buffer text ``under'' it does. */
7238 = MATRIX_ROW (w
->current_matrix
, vpos
);
7239 int start
= MATRIX_ROW_START_CHARPOS (r
);
7240 int pos
= string_buffer_position (w
, object
, start
);
7243 help
= Fget_char_property (make_number (pos
),
7244 Qhelp_echo
, w
->buffer
);
7253 else if (BUFFERP (object
)
7256 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
7262 help_echo_window
= window
;
7263 help_echo_object
= object
;
7264 help_echo_pos
= charpos
;
7271 current_buffer
= obuf
;
7277 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7281 redo_mouse_highlight ()
7283 if (!NILP (last_mouse_motion_frame
)
7284 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
7285 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
7286 last_mouse_motion_event
.x
,
7287 last_mouse_motion_event
.y
);
7292 /***********************************************************************
7294 ***********************************************************************/
7296 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
7297 struct glyph
**, int *, int *, int *));
7299 /* Tool-bar item index of the item on which a mouse button was pressed
7302 static int last_tool_bar_item
;
7305 /* Get information about the tool-bar item at position X/Y on frame F.
7306 Return in *GLYPH a pointer to the glyph of the tool-bar item in
7307 the current matrix of the tool-bar window of F, or NULL if not
7308 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
7309 item in F->tool_bar_items. Value is
7311 -1 if X/Y is not on a tool-bar item
7312 0 if X/Y is on the same item that was highlighted before.
7316 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
7319 struct glyph
**glyph
;
7320 int *hpos
, *vpos
, *prop_idx
;
7322 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7323 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7326 /* Find the glyph under X/Y. */
7327 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
, 0);
7331 /* Get the start of this tool-bar item's properties in
7332 f->tool_bar_items. */
7333 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
7336 /* Is mouse on the highlighted item? */
7337 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
7338 && *vpos
>= dpyinfo
->mouse_face_beg_row
7339 && *vpos
<= dpyinfo
->mouse_face_end_row
7340 && (*vpos
> dpyinfo
->mouse_face_beg_row
7341 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
7342 && (*vpos
< dpyinfo
->mouse_face_end_row
7343 || *hpos
< dpyinfo
->mouse_face_end_col
7344 || dpyinfo
->mouse_face_past_end
))
7351 /* Handle mouse button event on the tool-bar of frame F, at
7352 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
7356 x_handle_tool_bar_click (f
, button_event
)
7358 XButtonEvent
*button_event
;
7360 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7361 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7362 int hpos
, vpos
, prop_idx
;
7363 struct glyph
*glyph
;
7364 Lisp_Object enabled_p
;
7365 int x
= button_event
->x
;
7366 int y
= button_event
->y
;
7368 /* If not on the highlighted tool-bar item, return. */
7369 frame_to_window_pixel_xy (w
, &x
, &y
);
7370 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
7373 /* If item is disabled, do nothing. */
7374 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7375 if (NILP (enabled_p
))
7378 if (button_event
->type
== ButtonPress
)
7380 /* Show item in pressed state. */
7381 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
7382 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
7383 last_tool_bar_item
= prop_idx
;
7387 Lisp_Object key
, frame
;
7388 struct input_event event
;
7390 /* Show item in released state. */
7391 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
7392 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
7394 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
7396 XSETFRAME (frame
, f
);
7397 event
.kind
= TOOL_BAR_EVENT
;
7398 event
.frame_or_window
= frame
;
7400 kbd_buffer_store_event (&event
);
7402 event
.kind
= TOOL_BAR_EVENT
;
7403 event
.frame_or_window
= frame
;
7405 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
7406 button_event
->state
);
7407 kbd_buffer_store_event (&event
);
7408 last_tool_bar_item
= -1;
7413 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7414 tool-bar window-relative coordinates X/Y. Called from
7415 note_mouse_highlight. */
7418 note_tool_bar_highlight (f
, x
, y
)
7422 Lisp_Object window
= f
->tool_bar_window
;
7423 struct window
*w
= XWINDOW (window
);
7424 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7426 struct glyph
*glyph
;
7427 struct glyph_row
*row
;
7429 Lisp_Object enabled_p
;
7431 enum draw_glyphs_face draw
;
7432 int mouse_down_p
, rc
;
7434 /* Function note_mouse_highlight is called with negative x(y
7435 values when mouse moves outside of the frame. */
7436 if (x
<= 0 || y
<= 0)
7438 clear_mouse_face (dpyinfo
);
7442 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
7445 /* Not on tool-bar item. */
7446 clear_mouse_face (dpyinfo
);
7452 clear_mouse_face (dpyinfo
);
7454 /* Mouse is down, but on different tool-bar item? */
7455 mouse_down_p
= (dpyinfo
->grabbed
7456 && f
== last_mouse_frame
7457 && FRAME_LIVE_P (f
));
7459 && last_tool_bar_item
!= prop_idx
)
7462 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
7463 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
7465 /* If tool-bar item is not enabled, don't highlight it. */
7466 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7467 if (!NILP (enabled_p
))
7469 /* Compute the x-position of the glyph. In front and past the
7470 image is a space. We include this is the highlighted area. */
7471 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
7472 for (i
= x
= 0; i
< hpos
; ++i
)
7473 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
7475 /* Record this as the current active region. */
7476 dpyinfo
->mouse_face_beg_col
= hpos
;
7477 dpyinfo
->mouse_face_beg_row
= vpos
;
7478 dpyinfo
->mouse_face_beg_x
= x
;
7479 dpyinfo
->mouse_face_beg_y
= row
->y
;
7480 dpyinfo
->mouse_face_past_end
= 0;
7482 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
7483 dpyinfo
->mouse_face_end_row
= vpos
;
7484 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
7485 dpyinfo
->mouse_face_end_y
= row
->y
;
7486 dpyinfo
->mouse_face_window
= window
;
7487 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
7489 /* Display it as active. */
7490 show_mouse_face (dpyinfo
, draw
);
7491 dpyinfo
->mouse_face_image_state
= draw
;
7496 /* Set help_echo to a help string to display for this tool-bar item.
7497 XTread_socket does the rest. */
7498 help_echo_object
= help_echo_window
= Qnil
;
7500 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
7501 if (NILP (help_echo
))
7502 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
7507 /* Find the glyph matrix position of buffer position CHARPOS in window
7508 *W. HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7509 current glyphs must be up to date. If CHARPOS is above window
7510 start return (0, 0, 0, 0). If CHARPOS is after end of W, return end
7511 of last line in W. In the row containing CHARPOS, stop before glyphs
7512 having STOP as object. */
7514 #if 0 /* This is a version of fast_find_position that's more correct
7515 in the presence of hscrolling, for example. I didn't install
7516 it right away because the problem fixed is minor, it failed
7517 in 20.x as well, and I think it's too risky to install
7518 so near the release of 21.1. 2001-09-25 gerd. */
7521 fast_find_position (w
, charpos
, hpos
, vpos
, x
, y
, stop
)
7524 int *hpos
, *vpos
, *x
, *y
;
7527 struct glyph_row
*row
, *first
;
7528 struct glyph
*glyph
, *end
;
7529 int i
, past_end
= 0;
7531 first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7532 row
= row_containing_pos (w
, charpos
, first
, NULL
, 0);
7535 if (charpos
< MATRIX_ROW_START_CHARPOS (first
))
7537 *x
= *y
= *hpos
= *vpos
= 0;
7542 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
7549 *vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7551 glyph
= row
->glyphs
[TEXT_AREA
];
7552 end
= glyph
+ row
->used
[TEXT_AREA
];
7554 /* Skip over glyphs not having an object at the start of the row.
7555 These are special glyphs like truncation marks on terminal
7557 if (row
->displays_text_p
)
7559 && INTEGERP (glyph
->object
)
7560 && !EQ (stop
, glyph
->object
)
7561 && glyph
->charpos
< 0)
7563 *x
+= glyph
->pixel_width
;
7568 && !INTEGERP (glyph
->object
)
7569 && !EQ (stop
, glyph
->object
)
7570 && (!BUFFERP (glyph
->object
)
7571 || glyph
->charpos
< charpos
))
7573 *x
+= glyph
->pixel_width
;
7577 *hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
7584 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
, stop
)
7587 int *hpos
, *vpos
, *x
, *y
;
7592 int maybe_next_line_p
= 0;
7593 int line_start_position
;
7594 int yb
= window_text_bottom_y (w
);
7595 struct glyph_row
*row
, *best_row
;
7596 int row_vpos
, best_row_vpos
;
7599 row
= best_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7600 row_vpos
= best_row_vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7604 if (row
->used
[TEXT_AREA
])
7605 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
7607 line_start_position
= 0;
7609 if (line_start_position
> pos
)
7611 /* If the position sought is the end of the buffer,
7612 don't include the blank lines at the bottom of the window. */
7613 else if (line_start_position
== pos
7614 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
7616 maybe_next_line_p
= 1;
7619 else if (line_start_position
> 0)
7622 best_row_vpos
= row_vpos
;
7625 if (row
->y
+ row
->height
>= yb
)
7632 /* Find the right column within BEST_ROW. */
7634 current_x
= best_row
->x
;
7635 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
7637 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
7638 int charpos
= glyph
->charpos
;
7640 if (BUFFERP (glyph
->object
))
7645 *vpos
= best_row_vpos
;
7650 else if (charpos
> pos
)
7653 else if (EQ (glyph
->object
, stop
))
7658 current_x
+= glyph
->pixel_width
;
7661 /* If we're looking for the end of the buffer,
7662 and we didn't find it in the line we scanned,
7663 use the start of the following line. */
7664 if (maybe_next_line_p
)
7669 current_x
= best_row
->x
;
7672 *vpos
= best_row_vpos
;
7673 *hpos
= lastcol
+ 1;
7682 /* Find the position of the glyph for position POS in OBJECT in
7683 window W's current matrix, and return in *X, *Y the pixel
7684 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
7686 RIGHT_P non-zero means return the position of the right edge of the
7687 glyph, RIGHT_P zero means return the left edge position.
7689 If no glyph for POS exists in the matrix, return the position of
7690 the glyph with the next smaller position that is in the matrix, if
7691 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
7692 exists in the matrix, return the position of the glyph with the
7693 next larger position in OBJECT.
7695 Value is non-zero if a glyph was found. */
7698 fast_find_string_pos (w
, pos
, object
, hpos
, vpos
, x
, y
, right_p
)
7702 int *hpos
, *vpos
, *x
, *y
;
7705 int yb
= window_text_bottom_y (w
);
7706 struct glyph_row
*r
;
7707 struct glyph
*best_glyph
= NULL
;
7708 struct glyph_row
*best_row
= NULL
;
7711 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7712 r
->enabled_p
&& r
->y
< yb
;
7715 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7716 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
7719 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
7720 if (EQ (g
->object
, object
))
7722 if (g
->charpos
== pos
)
7729 else if (best_glyph
== NULL
7730 || ((abs (g
->charpos
- pos
)
7731 < abs (best_glyph
->charpos
- pos
))
7734 : g
->charpos
> pos
)))
7748 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
7752 *x
+= best_glyph
->pixel_width
;
7757 *vpos
= best_row
- w
->current_matrix
->rows
;
7760 return best_glyph
!= NULL
;
7764 /* Display the active region described by mouse_face_*
7765 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7768 show_mouse_face (dpyinfo
, draw
)
7769 struct x_display_info
*dpyinfo
;
7770 enum draw_glyphs_face draw
;
7772 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
7773 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7775 if (/* If window is in the process of being destroyed, don't bother
7777 w
->current_matrix
!= NULL
7778 /* Don't update mouse highlight if hidden */
7779 && (draw
!= DRAW_MOUSE_FACE
|| !dpyinfo
->mouse_face_hidden
)
7780 /* Recognize when we are called to operate on rows that don't exist
7781 anymore. This can happen when a window is split. */
7782 && dpyinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
7784 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
7785 struct glyph_row
*row
, *first
, *last
;
7787 first
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_beg_row
);
7788 last
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_end_row
);
7790 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
7792 int start_hpos
, end_hpos
, start_x
;
7794 /* For all but the first row, the highlight starts at column 0. */
7797 start_hpos
= dpyinfo
->mouse_face_beg_col
;
7798 start_x
= dpyinfo
->mouse_face_beg_x
;
7807 end_hpos
= dpyinfo
->mouse_face_end_col
;
7809 end_hpos
= row
->used
[TEXT_AREA
];
7811 if (end_hpos
> start_hpos
)
7813 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
7814 start_hpos
, end_hpos
, draw
, 0);
7817 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
7821 /* When we've written over the cursor, arrange for it to
7822 be displayed again. */
7823 if (phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
7824 x_display_cursor (w
, 1,
7825 w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
7826 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
7829 /* Change the mouse cursor. */
7830 if (draw
== DRAW_NORMAL_TEXT
)
7831 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7832 f
->output_data
.x
->text_cursor
);
7833 else if (draw
== DRAW_MOUSE_FACE
)
7834 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7835 f
->output_data
.x
->cross_cursor
);
7837 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7838 f
->output_data
.x
->nontext_cursor
);
7841 /* Clear out the mouse-highlighted active region.
7842 Redraw it un-highlighted first. Value is non-zero if mouse
7843 face was actually drawn unhighlighted. */
7846 clear_mouse_face (dpyinfo
)
7847 struct x_display_info
*dpyinfo
;
7851 if (!NILP (dpyinfo
->mouse_face_window
))
7853 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7857 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7858 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7859 dpyinfo
->mouse_face_window
= Qnil
;
7860 dpyinfo
->mouse_face_overlay
= Qnil
;
7865 /* Clear any mouse-face on window W. This function is part of the
7866 redisplay interface, and is called from try_window_id and similar
7867 functions to ensure the mouse-highlight is off. */
7870 x_clear_mouse_face (w
)
7873 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
7877 XSETWINDOW (window
, w
);
7878 if (EQ (window
, dpyinfo
->mouse_face_window
))
7879 clear_mouse_face (dpyinfo
);
7884 /* Just discard the mouse face information for frame F, if any.
7885 This is used when the size of F is changed. */
7888 cancel_mouse_face (f
)
7892 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7894 window
= dpyinfo
->mouse_face_window
;
7895 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7897 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7898 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7899 dpyinfo
->mouse_face_window
= Qnil
;
7904 static int glyph_rect
P_ ((struct frame
*f
, int, int, XRectangle
*));
7907 /* Try to determine frame pixel position and size of the glyph under
7908 frame pixel coordinates X/Y on frame F . Return the position and
7909 size in *RECT. Value is non-zero if we could compute these
7913 glyph_rect (f
, x
, y
, rect
)
7919 int part
, found
= 0;
7921 window
= window_from_coordinates (f
, x
, y
, &part
, 0);
7924 struct window
*w
= XWINDOW (window
);
7925 struct glyph_row
*r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7926 struct glyph_row
*end
= r
+ w
->current_matrix
->nrows
- 1;
7928 frame_to_window_pixel_xy (w
, &x
, &y
);
7930 for (; !found
&& r
< end
&& r
->enabled_p
; ++r
)
7933 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7934 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
7937 for (gx
= r
->x
; !found
&& g
< end
; gx
+= g
->pixel_width
, ++g
)
7940 rect
->width
= g
->pixel_width
;
7941 rect
->height
= r
->height
;
7942 rect
->x
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
7943 rect
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
7953 /* Return the current position of the mouse.
7954 *FP should be a frame which indicates which display to ask about.
7956 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
7957 and *PART to the frame, window, and scroll bar part that the mouse
7958 is over. Set *X and *Y to the portion and whole of the mouse's
7959 position on the scroll bar.
7961 If the mouse movement started elsewhere, set *FP to the frame the
7962 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
7965 Set *TIME to the server time-stamp for the time at which the mouse
7966 was at this position.
7968 Don't store anything if we don't have a valid set of values to report.
7970 This clears the mouse_moved flag, so we can wait for the next mouse
7974 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7977 Lisp_Object
*bar_window
;
7978 enum scroll_bar_part
*part
;
7980 unsigned long *time
;
7986 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7987 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7993 Window dummy_window
;
7996 Lisp_Object frame
, tail
;
7998 /* Clear the mouse-moved flag for every frame on this display. */
7999 FOR_EACH_FRAME (tail
, frame
)
8000 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
8001 XFRAME (frame
)->mouse_moved
= 0;
8003 last_mouse_scroll_bar
= Qnil
;
8005 /* Figure out which root window we're on. */
8006 XQueryPointer (FRAME_X_DISPLAY (*fp
),
8007 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
8009 /* The root window which contains the pointer. */
8012 /* Trash which we can't trust if the pointer is on
8013 a different screen. */
8016 /* The position on that root window. */
8019 /* More trash we can't trust. */
8022 /* Modifier keys and pointer buttons, about which
8024 (unsigned int *) &dummy
);
8026 /* Now we have a position on the root; find the innermost window
8027 containing the pointer. */
8031 int parent_x
= 0, parent_y
= 0;
8036 /* XTranslateCoordinates can get errors if the window
8037 structure is changing at the same time this function
8038 is running. So at least we must not crash from them. */
8040 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
8042 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
8043 && FRAME_LIVE_P (last_mouse_frame
))
8045 /* If mouse was grabbed on a frame, give coords for that frame
8046 even if the mouse is now outside it. */
8047 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
8049 /* From-window, to-window. */
8050 root
, FRAME_X_WINDOW (last_mouse_frame
),
8052 /* From-position, to-position. */
8053 root_x
, root_y
, &win_x
, &win_y
,
8057 f1
= last_mouse_frame
;
8063 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
8065 /* From-window, to-window. */
8068 /* From-position, to-position. */
8069 root_x
, root_y
, &win_x
, &win_y
,
8074 if (child
== None
|| child
== win
)
8082 /* Now we know that:
8083 win is the innermost window containing the pointer
8084 (XTC says it has no child containing the pointer),
8085 win_x and win_y are the pointer's position in it
8086 (XTC did this the last time through), and
8087 parent_x and parent_y are the pointer's position in win's parent.
8088 (They are what win_x and win_y were when win was child.
8089 If win is the root window, it has no parent, and
8090 parent_{x,y} are invalid, but that's okay, because we'll
8091 never use them in that case.) */
8093 /* Is win one of our frames? */
8094 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
8096 #ifdef USE_X_TOOLKIT
8097 /* If we end up with the menu bar window, say it's not
8100 && f1
->output_data
.x
->menubar_widget
8101 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
8103 #endif /* USE_X_TOOLKIT */
8106 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
8109 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
8111 /* If not, is it one of our scroll bars? */
8114 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
8118 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8124 if (f1
== 0 && insist
> 0)
8125 f1
= SELECTED_FRAME ();
8129 /* Ok, we found a frame. Store all the values.
8130 last_mouse_glyph is a rectangle used to reduce the
8131 generation of mouse events. To not miss any motion
8132 events, we must divide the frame into rectangles of the
8133 size of the smallest character that could be displayed
8134 on it, i.e. into the same rectangles that matrices on
8135 the frame are divided into. */
8137 int width
, height
, gx
, gy
;
8140 if (glyph_rect (f1
, win_x
, win_y
, &rect
))
8141 last_mouse_glyph
= rect
;
8144 width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
8145 height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
8149 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
8150 round down even for negative values. */
8155 gx
= (gx
+ width
- 1) / width
* width
;
8156 gy
= (gy
+ height
- 1) / height
* height
;
8158 last_mouse_glyph
.width
= width
;
8159 last_mouse_glyph
.height
= height
;
8160 last_mouse_glyph
.x
= gx
;
8161 last_mouse_glyph
.y
= gy
;
8167 XSETINT (*x
, win_x
);
8168 XSETINT (*y
, win_y
);
8169 *time
= last_mouse_movement_time
;
8178 #ifdef USE_X_TOOLKIT
8180 /* Atimer callback function for TIMER. Called every 0.1s to process
8181 Xt timeouts, if needed. We must avoid calling XtAppPending as
8182 much as possible because that function does an implicit XFlush
8183 that slows us down. */
8186 x_process_timeouts (timer
)
8187 struct atimer
*timer
;
8189 if (toolkit_scroll_bar_interaction
|| popup_activated_flag
)
8192 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
8193 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
8198 #endif /* USE_X_TOOLKIT */
8201 /* Scroll bar support. */
8203 /* Given an X window ID, find the struct scroll_bar which manages it.
8204 This can be called in GC, so we have to make sure to strip off mark
8207 static struct scroll_bar
*
8208 x_window_to_scroll_bar (window_id
)
8213 for (tail
= Vframe_list
;
8214 XGCTYPE (tail
) == Lisp_Cons
;
8217 Lisp_Object frame
, bar
, condemned
;
8219 frame
= XCAR (tail
);
8220 /* All elements of Vframe_list should be frames. */
8221 if (! GC_FRAMEP (frame
))
8224 /* Scan this frame's scroll bar list for a scroll bar with the
8226 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
8227 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
8228 /* This trick allows us to search both the ordinary and
8229 condemned scroll bar lists with one loop. */
8230 ! GC_NILP (bar
) || (bar
= condemned
,
8233 bar
= XSCROLL_BAR (bar
)->next
)
8234 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
8235 return XSCROLL_BAR (bar
);
8242 #if defined USE_LUCID
8244 /* Return the Lucid menu bar WINDOW is part of. Return null
8245 if WINDOW is not part of a menu bar. */
8248 x_window_to_menu_bar (window
)
8253 for (tail
= Vframe_list
;
8254 XGCTYPE (tail
) == Lisp_Cons
;
8257 Lisp_Object frame
= XCAR (tail
);
8258 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
8260 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
8267 #endif /* USE_LUCID */
8270 /************************************************************************
8272 ************************************************************************/
8274 #ifdef USE_TOOLKIT_SCROLL_BARS
8276 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
8277 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
8278 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
8279 struct scroll_bar
*));
8280 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
8284 /* Id of action hook installed for scroll bars. */
8286 static XtActionHookId action_hook_id
;
8288 /* Lisp window being scrolled. Set when starting to interact with
8289 a toolkit scroll bar, reset to nil when ending the interaction. */
8291 static Lisp_Object window_being_scrolled
;
8293 /* Last scroll bar part sent in xm_scroll_callback. */
8295 static int last_scroll_bar_part
;
8297 /* Whether this is an Xaw with arrow-scrollbars. This should imply
8298 that movements of 1/20 of the screen size are mapped to up/down. */
8300 static Boolean xaw3d_arrow_scroll
;
8302 /* Whether the drag scrolling maintains the mouse at the top of the
8303 thumb. If not, resizing the thumb needs to be done more carefully
8304 to avoid jerkyness. */
8306 static Boolean xaw3d_pick_top
;
8309 /* Action hook installed via XtAppAddActionHook when toolkit scroll
8310 bars are used.. The hook is responsible for detecting when
8311 the user ends an interaction with the scroll bar, and generates
8312 a `end-scroll' scroll_bar_click' event if so. */
8315 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
8318 XtPointer client_data
;
8322 Cardinal
*num_params
;
8328 scroll_bar_p
= XmIsScrollBar (widget
);
8329 end_action
= "Release";
8330 #else /* !USE_MOTIF i.e. use Xaw */
8331 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
8332 end_action
= "EndScroll";
8333 #endif /* USE_MOTIF */
8336 && strcmp (action_name
, end_action
) == 0
8337 && WINDOWP (window_being_scrolled
))
8341 x_send_scroll_bar_event (window_being_scrolled
,
8342 scroll_bar_end_scroll
, 0, 0);
8343 w
= XWINDOW (window_being_scrolled
);
8344 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
8345 window_being_scrolled
= Qnil
;
8346 last_scroll_bar_part
= -1;
8348 /* Xt timeouts no longer needed. */
8349 toolkit_scroll_bar_interaction
= 0;
8353 /* A vector of windows used for communication between
8354 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
8356 static struct window
**scroll_bar_windows
;
8357 static int scroll_bar_windows_size
;
8360 /* Send a client message with message type Xatom_Scrollbar for a
8361 scroll action to the frame of WINDOW. PART is a value identifying
8362 the part of the scroll bar that was clicked on. PORTION is the
8363 amount to scroll of a whole of WHOLE. */
8366 x_send_scroll_bar_event (window
, part
, portion
, whole
)
8368 int part
, portion
, whole
;
8371 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
8372 struct window
*w
= XWINDOW (window
);
8373 struct frame
*f
= XFRAME (w
->frame
);
8378 /* Construct a ClientMessage event to send to the frame. */
8379 ev
->type
= ClientMessage
;
8380 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
8381 ev
->display
= FRAME_X_DISPLAY (f
);
8382 ev
->window
= FRAME_X_WINDOW (f
);
8385 /* We can only transfer 32 bits in the XClientMessageEvent, which is
8386 not enough to store a pointer or Lisp_Object on a 64 bit system.
8387 So, store the window in scroll_bar_windows and pass the index
8388 into that array in the event. */
8389 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
8390 if (scroll_bar_windows
[i
] == NULL
)
8393 if (i
== scroll_bar_windows_size
)
8395 int new_size
= max (10, 2 * scroll_bar_windows_size
);
8396 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
8397 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
8399 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
8401 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
8402 scroll_bar_windows_size
= new_size
;
8405 scroll_bar_windows
[i
] = w
;
8406 ev
->data
.l
[0] = (long) i
;
8407 ev
->data
.l
[1] = (long) part
;
8408 ev
->data
.l
[2] = (long) 0;
8409 ev
->data
.l
[3] = (long) portion
;
8410 ev
->data
.l
[4] = (long) whole
;
8412 /* Make Xt timeouts work while the scroll bar is active. */
8413 toolkit_scroll_bar_interaction
= 1;
8415 /* Setting the event mask to zero means that the message will
8416 be sent to the client that created the window, and if that
8417 window no longer exists, no event will be sent. */
8418 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
8423 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
8427 x_scroll_bar_to_input_event (event
, ievent
)
8429 struct input_event
*ievent
;
8431 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
8436 w
= scroll_bar_windows
[ev
->data
.l
[0]];
8437 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
8439 XSETWINDOW (window
, w
);
8440 f
= XFRAME (w
->frame
);
8442 ievent
->kind
= scroll_bar_click
;
8443 ievent
->frame_or_window
= window
;
8445 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
8446 ievent
->part
= ev
->data
.l
[1];
8447 ievent
->code
= ev
->data
.l
[2];
8448 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
8449 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
8450 ievent
->modifiers
= 0;
8456 /* Minimum and maximum values used for Motif scroll bars. */
8459 #define XM_SB_MAX 10000000
8460 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
8463 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
8464 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
8465 CALL_DATA is a pointer a a XmScrollBarCallbackStruct. */
8468 xm_scroll_callback (widget
, client_data
, call_data
)
8470 XtPointer client_data
, call_data
;
8472 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8473 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
8474 int part
= -1, whole
= 0, portion
= 0;
8478 case XmCR_DECREMENT
:
8479 bar
->dragging
= Qnil
;
8480 part
= scroll_bar_up_arrow
;
8483 case XmCR_INCREMENT
:
8484 bar
->dragging
= Qnil
;
8485 part
= scroll_bar_down_arrow
;
8488 case XmCR_PAGE_DECREMENT
:
8489 bar
->dragging
= Qnil
;
8490 part
= scroll_bar_above_handle
;
8493 case XmCR_PAGE_INCREMENT
:
8494 bar
->dragging
= Qnil
;
8495 part
= scroll_bar_below_handle
;
8499 bar
->dragging
= Qnil
;
8500 part
= scroll_bar_to_top
;
8503 case XmCR_TO_BOTTOM
:
8504 bar
->dragging
= Qnil
;
8505 part
= scroll_bar_to_bottom
;
8511 int dragging_down_p
= (INTEGERP (bar
->dragging
)
8512 && XINT (bar
->dragging
) <= cs
->value
);
8514 /* Get the slider size. */
8516 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
8519 whole
= XM_SB_RANGE
- slider_size
;
8520 portion
= min (cs
->value
- XM_SB_MIN
, whole
);
8521 part
= scroll_bar_handle
;
8522 bar
->dragging
= make_number (cs
->value
);
8526 case XmCR_VALUE_CHANGED
:
8532 window_being_scrolled
= bar
->window
;
8533 last_scroll_bar_part
= part
;
8534 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
8539 #else /* !USE_MOTIF, i.e. Xaw. */
8542 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
8543 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
8544 scroll bar struct. CALL_DATA is a pointer to a float saying where
8548 xaw_jump_callback (widget
, client_data
, call_data
)
8550 XtPointer client_data
, call_data
;
8552 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8553 float top
= *(float *) call_data
;
8555 int whole
, portion
, height
;
8558 /* Get the size of the thumb, a value between 0 and 1. */
8560 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
8564 portion
= shown
< 1 ? top
* whole
: 0;
8566 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
8567 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
8568 the bottom, so we force the scrolling whenever we see that we're
8569 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
8570 we try to ensure that we always stay two pixels away from the
8572 part
= scroll_bar_down_arrow
;
8574 part
= scroll_bar_handle
;
8576 window_being_scrolled
= bar
->window
;
8577 bar
->dragging
= make_number (portion
);
8578 last_scroll_bar_part
= part
;
8579 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
8583 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
8584 i.e. line or page up or down. WIDGET is the Xaw scroll bar
8585 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
8586 the scroll bar. CALL_DATA is an integer specifying the action that
8587 has taken place. It's magnitude is in the range 0..height of the
8588 scroll bar. Negative values mean scroll towards buffer start.
8589 Values < height of scroll bar mean line-wise movement. */
8592 xaw_scroll_callback (widget
, client_data
, call_data
)
8594 XtPointer client_data
, call_data
;
8596 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8597 int position
= (int) call_data
;
8601 /* Get the height of the scroll bar. */
8603 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
8606 if (abs (position
) >= height
)
8607 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
8609 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
8610 it maps line-movement to call_data = max(5, height/20). */
8611 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
8612 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
8614 part
= scroll_bar_move_ratio
;
8616 window_being_scrolled
= bar
->window
;
8617 bar
->dragging
= Qnil
;
8618 last_scroll_bar_part
= part
;
8619 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
8623 #endif /* not USE_MOTIF */
8626 /* Create the widget for scroll bar BAR on frame F. Record the widget
8627 and X window of the scroll bar in BAR. */
8630 x_create_toolkit_scroll_bar (f
, bar
)
8632 struct scroll_bar
*bar
;
8638 char *scroll_bar_name
= "verticalScrollBar";
8639 unsigned long pixel
;
8644 /* Set resources. Create the widget. */
8645 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8646 XtSetArg (av
[ac
], XmNminimum
, XM_SB_MIN
); ++ac
;
8647 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
8648 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
8649 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
8650 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
8651 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
8653 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8656 XtSetArg (av
[ac
], XmNforeground
, pixel
);
8660 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8663 XtSetArg (av
[ac
], XmNbackground
, pixel
);
8667 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
8668 scroll_bar_name
, av
, ac
);
8670 /* Add one callback for everything that can happen. */
8671 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
8673 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
8675 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
8677 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
8679 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
8681 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
8683 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
8686 /* Realize the widget. Only after that is the X window created. */
8687 XtRealizeWidget (widget
);
8689 /* Set the cursor to an arrow. I didn't find a resource to do that.
8690 And I'm wondering why it hasn't an arrow cursor by default. */
8691 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
8692 f
->output_data
.x
->nontext_cursor
);
8694 #else /* !USE_MOTIF i.e. use Xaw */
8696 /* Set resources. Create the widget. The background of the
8697 Xaw3d scroll bar widget is a little bit light for my taste.
8698 We don't alter it here to let users change it according
8699 to their taste with `emacs*verticalScrollBar.background: xxx'. */
8700 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8701 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
8702 /* For smoother scrolling with Xaw3d -sm */
8703 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
8705 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8708 XtSetArg (av
[ac
], XtNforeground
, pixel
);
8712 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8715 XtSetArg (av
[ac
], XtNbackground
, pixel
);
8719 /* Top/bottom shadow colors. */
8721 /* Allocate them, if necessary. */
8722 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
8724 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8725 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
8726 &pixel
, 1.2, 0x8000))
8728 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
8730 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
8732 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8733 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
8734 &pixel
, 0.6, 0x4000))
8736 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
8739 /* Tell the toolkit about them. */
8740 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
8741 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
8742 /* We tried to allocate a color for the top/bottom shadow, and
8743 failed, so tell Xaw3d to use dithering instead. */
8745 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
8749 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
8750 be more consistent with other emacs 3d colors, and since Xaw3d is
8751 not good at dealing with allocation failure. */
8753 /* This tells Xaw3d to use real colors instead of dithering for
8755 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
8758 /* Specify the colors. */
8759 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
8762 XtSetArg (av
[ac
], "topShadowPixel", pixel
);
8765 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
8768 XtSetArg (av
[ac
], "bottomShadowPixel", pixel
);
8773 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
8774 f
->output_data
.x
->edit_widget
, av
, ac
);
8778 char *val
= initial
;
8779 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
8780 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
8782 { /* ARROW_SCROLL */
8783 xaw3d_arrow_scroll
= True
;
8784 /* Isn't that just a personal preference ? -sm */
8785 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
8789 /* Define callbacks. */
8790 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
8791 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
8794 /* Realize the widget. Only after that is the X window created. */
8795 XtRealizeWidget (widget
);
8797 #endif /* !USE_MOTIF */
8799 /* Install an action hook that let's us detect when the user
8800 finishes interacting with a scroll bar. */
8801 if (action_hook_id
== 0)
8802 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
8804 /* Remember X window and widget in the scroll bar vector. */
8805 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
8806 xwindow
= XtWindow (widget
);
8807 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
8813 /* Set the thumb size and position of scroll bar BAR. We are currently
8814 displaying PORTION out of a whole WHOLE, and our position POSITION. */
8817 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
8818 struct scroll_bar
*bar
;
8819 int portion
, position
, whole
;
8821 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8822 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
8829 /* We use an estimate of 30 chars per line rather than the real
8830 `portion' value. This has the disadvantage that the thumb size
8831 is not very representative, but it makes our life a lot easier.
8832 Otherwise, we have to constantly adjust the thumb size, which
8833 we can't always do quickly enough: while dragging, the size of
8834 the thumb might prevent the user from dragging the thumb all the
8835 way to the end. but Motif and some versions of Xaw3d don't allow
8836 updating the thumb size while dragging. Also, even if we can update
8837 its size, the update will often happen too late.
8838 If you don't believe it, check out revision 1.650 of xterm.c to see
8839 what hoops we were going through and the still poor behavior we got. */
8840 portion
= XFASTINT (XWINDOW (bar
->window
)->height
) * 30;
8841 /* When the thumb is at the bottom, position == whole.
8842 So we need to increase `whole' to make space for the thumb. */
8849 top
= (float) position
/ whole
;
8850 shown
= (float) portion
/ whole
;
8853 if (NILP (bar
->dragging
))
8857 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
8858 is the scroll bar's maximum and MIN is the scroll bar's minimum
8860 size
= shown
* XM_SB_RANGE
;
8861 size
= min (size
, XM_SB_RANGE
);
8862 size
= max (size
, 1);
8864 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
8865 value
= top
* XM_SB_RANGE
;
8866 value
= min (value
, XM_SB_MAX
- size
);
8867 value
= max (value
, XM_SB_MIN
);
8869 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
8871 #else /* !USE_MOTIF i.e. use Xaw */
8877 top
= (float) position
/ whole
;
8878 shown
= (float) portion
/ whole
;
8882 float old_top
, old_shown
;
8884 XtVaGetValues (widget
,
8885 XtNtopOfThumb
, &old_top
,
8886 XtNshown
, &old_shown
,
8890 /* Massage the top+shown values. */
8891 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
8892 top
= max (0, min (1, top
));
8895 /* Keep two pixels available for moving the thumb down. */
8896 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
8898 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
8899 check that your system's configuration file contains a define
8900 for `NARROWPROTO'. See s/freebsd.h for an example. */
8901 if (top
!= old_top
|| shown
!= old_shown
)
8903 if (NILP (bar
->dragging
))
8904 XawScrollbarSetThumb (widget
, top
, shown
);
8908 ScrollbarWidget sb
= (ScrollbarWidget
) widget
;
8909 int scroll_mode
= 0;
8911 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
8912 if (xaw3d_arrow_scroll
)
8914 /* Xaw3d stupidly ignores resize requests while dragging
8915 so we have to make it believe it's not in dragging mode. */
8916 scroll_mode
= sb
->scrollbar
.scroll_mode
;
8917 if (scroll_mode
== 2)
8918 sb
->scrollbar
.scroll_mode
= 0;
8921 /* Try to make the scrolling a tad smoother. */
8922 if (!xaw3d_pick_top
)
8923 shown
= min (shown
, old_shown
);
8925 XawScrollbarSetThumb (widget
, top
, shown
);
8928 if (xaw3d_arrow_scroll
&& scroll_mode
== 2)
8929 sb
->scrollbar
.scroll_mode
= scroll_mode
;
8934 #endif /* !USE_MOTIF */
8939 #endif /* USE_TOOLKIT_SCROLL_BARS */
8943 /************************************************************************
8944 Scroll bars, general
8945 ************************************************************************/
8947 /* Create a scroll bar and return the scroll bar vector for it. W is
8948 the Emacs window on which to create the scroll bar. TOP, LEFT,
8949 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
8952 static struct scroll_bar
*
8953 x_scroll_bar_create (w
, top
, left
, width
, height
)
8955 int top
, left
, width
, height
;
8957 struct frame
*f
= XFRAME (w
->frame
);
8958 struct scroll_bar
*bar
8959 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
8963 #ifdef USE_TOOLKIT_SCROLL_BARS
8964 x_create_toolkit_scroll_bar (f
, bar
);
8965 #else /* not USE_TOOLKIT_SCROLL_BARS */
8967 XSetWindowAttributes a
;
8971 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8972 if (a
.background_pixel
== -1)
8973 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
8975 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
8976 | ButtonMotionMask
| PointerMotionHintMask
8978 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
8980 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
8982 /* Clear the area of W that will serve as a scroll bar. This is
8983 for the case that a window has been split horizontally. In
8984 this case, no clear_frame is generated to reduce flickering. */
8985 if (width
> 0 && height
> 0)
8986 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8988 window_box_height (w
), False
);
8990 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8991 /* Position and size of scroll bar. */
8992 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8994 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8996 /* Border width, depth, class, and visual. */
9003 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
9005 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9007 XSETWINDOW (bar
->window
, w
);
9008 XSETINT (bar
->top
, top
);
9009 XSETINT (bar
->left
, left
);
9010 XSETINT (bar
->width
, width
);
9011 XSETINT (bar
->height
, height
);
9012 XSETINT (bar
->start
, 0);
9013 XSETINT (bar
->end
, 0);
9014 bar
->dragging
= Qnil
;
9016 /* Add bar to its frame's list of scroll bars. */
9017 bar
->next
= FRAME_SCROLL_BARS (f
);
9019 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
9020 if (!NILP (bar
->next
))
9021 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
9023 /* Map the window/widget. */
9024 #ifdef USE_TOOLKIT_SCROLL_BARS
9026 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
9027 XtConfigureWidget (scroll_bar
,
9028 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9030 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
9031 max (height
, 1), 0);
9032 XtMapWidget (scroll_bar
);
9034 #else /* not USE_TOOLKIT_SCROLL_BARS */
9035 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
9036 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9043 /* Draw BAR's handle in the proper position.
9045 If the handle is already drawn from START to END, don't bother
9046 redrawing it, unless REBUILD is non-zero; in that case, always
9047 redraw it. (REBUILD is handy for drawing the handle after expose
9050 Normally, we want to constrain the start and end of the handle to
9051 fit inside its rectangle, but if the user is dragging the scroll
9052 bar handle, we want to let them drag it down all the way, so that
9053 the bar's top is as far down as it goes; otherwise, there's no way
9054 to move to the very end of the buffer. */
9056 #ifndef USE_TOOLKIT_SCROLL_BARS
9059 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
9060 struct scroll_bar
*bar
;
9064 int dragging
= ! NILP (bar
->dragging
);
9065 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9066 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9067 GC gc
= f
->output_data
.x
->normal_gc
;
9069 /* If the display is already accurate, do nothing. */
9071 && start
== XINT (bar
->start
)
9072 && end
== XINT (bar
->end
))
9078 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
9079 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9080 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9082 /* Make sure the values are reasonable, and try to preserve
9083 the distance between start and end. */
9085 int length
= end
- start
;
9089 else if (start
> top_range
)
9091 end
= start
+ length
;
9095 else if (end
> top_range
&& ! dragging
)
9099 /* Store the adjusted setting in the scroll bar. */
9100 XSETINT (bar
->start
, start
);
9101 XSETINT (bar
->end
, end
);
9103 /* Clip the end position, just for display. */
9104 if (end
> top_range
)
9107 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
9108 below top positions, to make sure the handle is always at least
9109 that many pixels tall. */
9110 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
9112 /* Draw the empty space above the handle. Note that we can't clear
9113 zero-height areas; that means "clear to end of window." */
9115 x_clear_area (FRAME_X_DISPLAY (f
), w
,
9116 /* x, y, width, height, and exposures. */
9117 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
9118 VERTICAL_SCROLL_BAR_TOP_BORDER
,
9119 inside_width
, start
,
9122 /* Change to proper foreground color if one is specified. */
9123 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9124 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
9125 f
->output_data
.x
->scroll_bar_foreground_pixel
);
9127 /* Draw the handle itself. */
9128 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
9129 /* x, y, width, height */
9130 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
9131 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
9132 inside_width
, end
- start
);
9134 /* Restore the foreground color of the GC if we changed it above. */
9135 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9136 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
9137 f
->output_data
.x
->foreground_pixel
);
9139 /* Draw the empty space below the handle. Note that we can't
9140 clear zero-height areas; that means "clear to end of window." */
9141 if (end
< inside_height
)
9142 x_clear_area (FRAME_X_DISPLAY (f
), w
,
9143 /* x, y, width, height, and exposures. */
9144 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
9145 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
9146 inside_width
, inside_height
- end
,
9154 #endif /* !USE_TOOLKIT_SCROLL_BARS */
9156 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
9160 x_scroll_bar_remove (bar
)
9161 struct scroll_bar
*bar
;
9163 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9166 #ifdef USE_TOOLKIT_SCROLL_BARS
9167 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
9169 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
9172 /* Disassociate this scroll bar from its window. */
9173 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
9179 /* Set the handle of the vertical scroll bar for WINDOW to indicate
9180 that we are displaying PORTION characters out of a total of WHOLE
9181 characters, starting at POSITION. If WINDOW has no scroll bar,
9185 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
9187 int portion
, whole
, position
;
9189 struct frame
*f
= XFRAME (w
->frame
);
9190 struct scroll_bar
*bar
;
9191 int top
, height
, left
, sb_left
, width
, sb_width
;
9192 int window_x
, window_y
, window_width
, window_height
;
9194 /* Get window dimensions. */
9195 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
9197 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
9198 height
= window_height
;
9200 /* Compute the left edge of the scroll bar area. */
9201 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9202 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
9204 left
= XFASTINT (w
->left
);
9205 left
*= CANON_X_UNIT (f
);
9206 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
9208 /* Compute the width of the scroll bar which might be less than
9209 the width of the area reserved for the scroll bar. */
9210 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
9211 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
9215 /* Compute the left edge of the scroll bar. */
9216 #ifdef USE_TOOLKIT_SCROLL_BARS
9217 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9218 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
9220 sb_left
= left
+ (width
- sb_width
) / 2;
9222 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9223 sb_left
= left
+ width
- sb_width
;
9228 /* Does the scroll bar exist yet? */
9229 if (NILP (w
->vertical_scroll_bar
))
9231 if (width
> 0 && height
> 0)
9234 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9235 left
, top
, width
, height
, False
);
9239 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
9243 /* It may just need to be moved and resized. */
9244 unsigned int mask
= 0;
9246 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
9250 if (sb_left
!= XINT (bar
->left
))
9252 if (top
!= XINT (bar
->top
))
9254 if (sb_width
!= XINT (bar
->width
))
9256 if (height
!= XINT (bar
->height
))
9259 #ifdef USE_TOOLKIT_SCROLL_BARS
9261 /* Since toolkit scroll bars are smaller than the space reserved
9262 for them on the frame, we have to clear "under" them. */
9263 if (width
> 0 && height
> 0)
9264 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9265 left
, top
, width
, height
, False
);
9267 /* Move/size the scroll bar widget. */
9269 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
9270 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9272 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
9273 max (height
, 1), 0);
9275 #else /* not USE_TOOLKIT_SCROLL_BARS */
9277 /* Clear areas not covered by the scroll bar because of
9278 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
9279 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
9281 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9282 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9284 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9285 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9286 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9290 /* Clear areas not covered by the scroll bar because it's not as
9291 wide as the area reserved for it. This makes sure a
9292 previous mode line display is cleared after C-x 2 C-x 1, for
9295 int area_width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
9296 int rest
= area_width
- sb_width
;
9297 if (rest
> 0 && height
> 0)
9299 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
9300 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9301 left
+ area_width
- rest
, top
,
9302 rest
, height
, False
);
9304 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9305 left
, top
, rest
, height
, False
);
9309 /* Move/size the scroll bar window. */
9314 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
9316 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
9318 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
9322 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9324 /* Remember new settings. */
9325 XSETINT (bar
->left
, sb_left
);
9326 XSETINT (bar
->top
, top
);
9327 XSETINT (bar
->width
, sb_width
);
9328 XSETINT (bar
->height
, height
);
9333 #ifdef USE_TOOLKIT_SCROLL_BARS
9334 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
9335 #else /* not USE_TOOLKIT_SCROLL_BARS */
9336 /* Set the scroll bar's current state, unless we're currently being
9338 if (NILP (bar
->dragging
))
9340 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
9343 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
9346 int start
= ((double) position
* top_range
) / whole
;
9347 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
9348 x_scroll_bar_set_handle (bar
, start
, end
, 0);
9351 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9353 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
9357 /* The following three hooks are used when we're doing a thorough
9358 redisplay of the frame. We don't explicitly know which scroll bars
9359 are going to be deleted, because keeping track of when windows go
9360 away is a real pain - "Can you say set-window-configuration, boys
9361 and girls?" Instead, we just assert at the beginning of redisplay
9362 that *all* scroll bars are to be removed, and then save a scroll bar
9363 from the fiery pit when we actually redisplay its window. */
9365 /* Arrange for all scroll bars on FRAME to be removed at the next call
9366 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
9367 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
9370 XTcondemn_scroll_bars (frame
)
9373 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
9374 while (! NILP (FRAME_SCROLL_BARS (frame
)))
9377 bar
= FRAME_SCROLL_BARS (frame
);
9378 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
9379 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
9380 XSCROLL_BAR (bar
)->prev
= Qnil
;
9381 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
9382 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
9383 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
9388 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
9389 Note that WINDOW isn't necessarily condemned at all. */
9392 XTredeem_scroll_bar (window
)
9393 struct window
*window
;
9395 struct scroll_bar
*bar
;
9398 /* We can't redeem this window's scroll bar if it doesn't have one. */
9399 if (NILP (window
->vertical_scroll_bar
))
9402 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
9404 /* Unlink it from the condemned list. */
9405 f
= XFRAME (WINDOW_FRAME (window
));
9406 if (NILP (bar
->prev
))
9408 /* If the prev pointer is nil, it must be the first in one of
9410 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
9411 /* It's not condemned. Everything's fine. */
9413 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
9414 window
->vertical_scroll_bar
))
9415 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
9417 /* If its prev pointer is nil, it must be at the front of
9418 one or the other! */
9422 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
9424 if (! NILP (bar
->next
))
9425 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
9427 bar
->next
= FRAME_SCROLL_BARS (f
);
9429 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
9430 if (! NILP (bar
->next
))
9431 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
9434 /* Remove all scroll bars on FRAME that haven't been saved since the
9435 last call to `*condemn_scroll_bars_hook'. */
9438 XTjudge_scroll_bars (f
)
9441 Lisp_Object bar
, next
;
9443 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
9445 /* Clear out the condemned list now so we won't try to process any
9446 more events on the hapless scroll bars. */
9447 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
9449 for (; ! NILP (bar
); bar
= next
)
9451 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
9453 x_scroll_bar_remove (b
);
9456 b
->next
= b
->prev
= Qnil
;
9459 /* Now there should be no references to the condemned scroll bars,
9460 and they should get garbage-collected. */
9464 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
9465 is a no-op when using toolkit scroll bars.
9467 This may be called from a signal handler, so we have to ignore GC
9471 x_scroll_bar_expose (bar
, event
)
9472 struct scroll_bar
*bar
;
9475 #ifndef USE_TOOLKIT_SCROLL_BARS
9477 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9478 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9479 GC gc
= f
->output_data
.x
->normal_gc
;
9480 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
9484 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
9486 /* Draw a one-pixel border just inside the edges of the scroll bar. */
9487 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
9489 /* x, y, width, height */
9491 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
9492 XINT (bar
->height
) - 1);
9496 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9499 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
9500 is set to something other than no_event, it is enqueued.
9502 This may be called from a signal handler, so we have to ignore GC
9505 #ifndef USE_TOOLKIT_SCROLL_BARS
9508 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
9509 struct scroll_bar
*bar
;
9511 struct input_event
*emacs_event
;
9513 if (! GC_WINDOWP (bar
->window
))
9516 emacs_event
->kind
= scroll_bar_click
;
9517 emacs_event
->code
= event
->xbutton
.button
- Button1
;
9518 emacs_event
->modifiers
9519 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
9520 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
9521 event
->xbutton
.state
)
9522 | (event
->type
== ButtonRelease
9525 emacs_event
->frame_or_window
= bar
->window
;
9526 emacs_event
->arg
= Qnil
;
9527 emacs_event
->timestamp
= event
->xbutton
.time
;
9530 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9532 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9535 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9536 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
9539 if (y
> top_range
) y
= top_range
;
9541 if (y
< XINT (bar
->start
))
9542 emacs_event
->part
= scroll_bar_above_handle
;
9543 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
9544 emacs_event
->part
= scroll_bar_handle
;
9546 emacs_event
->part
= scroll_bar_below_handle
;
9548 /* Just because the user has clicked on the handle doesn't mean
9549 they want to drag it. Lisp code needs to be able to decide
9550 whether or not we're dragging. */
9552 /* If the user has just clicked on the handle, record where they're
9554 if (event
->type
== ButtonPress
9555 && emacs_event
->part
== scroll_bar_handle
)
9556 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
9559 /* If the user has released the handle, set it to its final position. */
9560 if (event
->type
== ButtonRelease
9561 && ! NILP (bar
->dragging
))
9563 int new_start
= y
- XINT (bar
->dragging
);
9564 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
9566 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
9567 bar
->dragging
= Qnil
;
9570 /* Same deal here as the other #if 0. */
9572 /* Clicks on the handle are always reported as occurring at the top of
9574 if (emacs_event
->part
== scroll_bar_handle
)
9575 emacs_event
->x
= bar
->start
;
9577 XSETINT (emacs_event
->x
, y
);
9579 XSETINT (emacs_event
->x
, y
);
9582 XSETINT (emacs_event
->y
, top_range
);
9586 /* Handle some mouse motion while someone is dragging the scroll bar.
9588 This may be called from a signal handler, so we have to ignore GC
9592 x_scroll_bar_note_movement (bar
, event
)
9593 struct scroll_bar
*bar
;
9596 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
9598 last_mouse_movement_time
= event
->xmotion
.time
;
9601 XSETVECTOR (last_mouse_scroll_bar
, bar
);
9603 /* If we're dragging the bar, display it. */
9604 if (! GC_NILP (bar
->dragging
))
9606 /* Where should the handle be now? */
9607 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
9609 if (new_start
!= XINT (bar
->start
))
9611 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
9613 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
9618 #endif /* !USE_TOOLKIT_SCROLL_BARS */
9620 /* Return information to the user about the current position of the mouse
9621 on the scroll bar. */
9624 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
9626 Lisp_Object
*bar_window
;
9627 enum scroll_bar_part
*part
;
9629 unsigned long *time
;
9631 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
9632 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9633 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9635 Window dummy_window
;
9637 unsigned int dummy_mask
;
9641 /* Get the mouse's position relative to the scroll bar window, and
9643 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
9645 /* Root, child, root x and root y. */
9646 &dummy_window
, &dummy_window
,
9647 &dummy_coord
, &dummy_coord
,
9649 /* Position relative to scroll bar. */
9652 /* Mouse buttons and modifier keys. */
9659 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9662 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9664 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
9666 if (! NILP (bar
->dragging
))
9667 win_y
-= XINT (bar
->dragging
);
9671 if (win_y
> top_range
)
9675 *bar_window
= bar
->window
;
9677 if (! NILP (bar
->dragging
))
9678 *part
= scroll_bar_handle
;
9679 else if (win_y
< XINT (bar
->start
))
9680 *part
= scroll_bar_above_handle
;
9681 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
9682 *part
= scroll_bar_handle
;
9684 *part
= scroll_bar_below_handle
;
9686 XSETINT (*x
, win_y
);
9687 XSETINT (*y
, top_range
);
9690 last_mouse_scroll_bar
= Qnil
;
9693 *time
= last_mouse_movement_time
;
9699 /* The screen has been cleared so we may have changed foreground or
9700 background colors, and the scroll bars may need to be redrawn.
9701 Clear out the scroll bars, and ask for expose events, so we can
9705 x_scroll_bar_clear (f
)
9708 #ifndef USE_TOOLKIT_SCROLL_BARS
9711 /* We can have scroll bars even if this is 0,
9712 if we just turned off scroll bar mode.
9713 But in that case we should not clear them. */
9714 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
9715 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
9716 bar
= XSCROLL_BAR (bar
)->next
)
9717 XClearArea (FRAME_X_DISPLAY (f
),
9718 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
9720 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9723 /* This processes Expose events from the menu-bar specific X event
9724 loop in xmenu.c. This allows to redisplay the frame if necessary
9725 when handling menu-bar or pop-up items. */
9728 process_expose_from_menu (event
)
9732 struct x_display_info
*dpyinfo
;
9733 int frame_exposed_p
= 0;
9737 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
9738 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
9741 if (f
->async_visible
== 0)
9743 f
->async_visible
= 1;
9744 f
->async_iconified
= 0;
9745 f
->output_data
.x
->has_been_visible
= 1;
9746 SET_FRAME_GARBAGED (f
);
9750 expose_frame (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
9751 event
.xexpose
.x
, event
.xexpose
.y
,
9752 event
.xexpose
.width
, event
.xexpose
.height
);
9753 frame_exposed_p
= 1;
9758 struct scroll_bar
*bar
9759 = x_window_to_scroll_bar (event
.xexpose
.window
);
9762 x_scroll_bar_expose (bar
, &event
);
9766 return frame_exposed_p
;
9769 /* Define a queue to save up SelectionRequest events for later handling. */
9771 struct selection_event_queue
9774 struct selection_event_queue
*next
;
9777 static struct selection_event_queue
*queue
;
9779 /* Nonzero means queue up certain events--don't process them yet. */
9781 static int x_queue_selection_requests
;
9783 /* Queue up an X event *EVENT, to be processed later. */
9786 x_queue_event (f
, event
)
9790 struct selection_event_queue
*queue_tmp
9791 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
9793 if (queue_tmp
!= NULL
)
9795 queue_tmp
->event
= *event
;
9796 queue_tmp
->next
= queue
;
9801 /* Take all the queued events and put them back
9802 so that they get processed afresh. */
9805 x_unqueue_events (display
)
9808 while (queue
!= NULL
)
9810 struct selection_event_queue
*queue_tmp
= queue
;
9811 XPutBackEvent (display
, &queue_tmp
->event
);
9812 queue
= queue_tmp
->next
;
9813 xfree ((char *)queue_tmp
);
9817 /* Start queuing SelectionRequest events. */
9820 x_start_queuing_selection_requests (display
)
9823 x_queue_selection_requests
++;
9826 /* Stop queuing SelectionRequest events. */
9829 x_stop_queuing_selection_requests (display
)
9832 x_queue_selection_requests
--;
9833 x_unqueue_events (display
);
9836 /* The main X event-reading loop - XTread_socket. */
9839 /* Time stamp of enter window event. This is only used by XTread_socket,
9840 but we have to put it out here, since static variables within functions
9841 sometimes don't work. */
9843 static Time enter_timestamp
;
9846 /* This holds the state XLookupString needs to implement dead keys
9847 and other tricks known as "compose processing". _X Window System_
9848 says that a portable program can't use this, but Stephen Gildea assures
9849 me that letting the compiler initialize it to zeros will work okay.
9851 This must be defined outside of XTread_socket, for the same reasons
9852 given for enter_timestamp, above. */
9854 static XComposeStatus compose_status
;
9856 /* Record the last 100 characters stored
9857 to help debug the loss-of-chars-during-GC problem. */
9859 static int temp_index
;
9860 static short temp_buffer
[100];
9862 /* Set this to nonzero to fake an "X I/O error"
9863 on a particular display. */
9865 struct x_display_info
*XTread_socket_fake_io_error
;
9867 /* When we find no input here, we occasionally do a no-op command
9868 to verify that the X server is still running and we can still talk with it.
9869 We try all the open displays, one by one.
9870 This variable is used for cycling thru the displays. */
9872 static struct x_display_info
*next_noop_dpyinfo
;
9874 #define SET_SAVED_MENU_EVENT(size) \
9877 if (f->output_data.x->saved_menu_event == 0) \
9878 f->output_data.x->saved_menu_event \
9879 = (XEvent *) xmalloc (sizeof (XEvent)); \
9880 bcopy (&event, f->output_data.x->saved_menu_event, size); \
9881 if (numchars >= 1) \
9883 bufp->kind = menu_bar_activate_event; \
9884 XSETFRAME (bufp->frame_or_window, f); \
9893 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
9894 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
9896 /* Read events coming from the X server.
9897 This routine is called by the SIGIO handler.
9898 We return as soon as there are no more events to be read.
9900 Events representing keys are stored in buffer BUFP,
9901 which can hold up to NUMCHARS characters.
9902 We return the number of characters stored into the buffer,
9903 thus pretending to be `read'.
9905 EXPECTED is nonzero if the caller knows input is available. */
9908 XTread_socket (sd
, bufp
, numchars
, expected
)
9910 /* register */ struct input_event
*bufp
;
9911 /* register */ int numchars
;
9918 int event_found
= 0;
9919 struct x_display_info
*dpyinfo
;
9920 struct coding_system coding
;
9922 if (interrupt_input_blocked
)
9924 interrupt_input_pending
= 1;
9928 interrupt_input_pending
= 0;
9931 /* So people can tell when we have read the available input. */
9932 input_signal_count
++;
9935 abort (); /* Don't think this happens. */
9939 /* Find the display we are supposed to read input for.
9940 It's the one communicating on descriptor SD. */
9941 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
9943 #if 0 /* This ought to be unnecessary; let's verify it. */
9945 /* If available, Xlib uses FIOSNBIO to make the socket
9946 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
9947 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
9948 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
9949 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
9950 #endif /* ! defined (FIOSNBIO) */
9953 #if 0 /* This code can't be made to work, with multiple displays,
9954 and appears not to be used on any system any more.
9955 Also keyboard.c doesn't turn O_NDELAY on and off
9956 for X connections. */
9959 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
9961 extern int read_alarm_should_throw
;
9962 read_alarm_should_throw
= 1;
9963 XPeekEvent (dpyinfo
->display
, &event
);
9964 read_alarm_should_throw
= 0;
9966 #endif /* HAVE_SELECT */
9970 /* For debugging, this gives a way to fake an I/O error. */
9971 if (dpyinfo
== XTread_socket_fake_io_error
)
9973 XTread_socket_fake_io_error
= 0;
9974 x_io_error_quitter (dpyinfo
->display
);
9979 count
+= x_session_check_input (bufp
, &numchars
);
9983 while (XPending (dpyinfo
->display
))
9985 XNextEvent (dpyinfo
->display
, &event
);
9989 /* Filter events for the current X input method.
9990 XFilterEvent returns non-zero if the input method has
9991 consumed the event. We pass the frame's X window to
9992 XFilterEvent because that's the one for which the IC
9994 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
9995 event
.xclient
.window
);
9996 if (XFilterEvent (&event
, f1
? FRAME_X_WINDOW (f1
) : None
))
10002 switch (event
.type
)
10004 case ClientMessage
:
10006 if (event
.xclient
.message_type
10007 == dpyinfo
->Xatom_wm_protocols
10008 && event
.xclient
.format
== 32)
10010 if (event
.xclient
.data
.l
[0]
10011 == dpyinfo
->Xatom_wm_take_focus
)
10013 /* Use x_any_window_to_frame because this
10014 could be the shell widget window
10015 if the frame has no title bar. */
10016 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
10018 /* Not quite sure this is needed -pd */
10019 if (f
&& FRAME_XIC (f
))
10020 XSetICFocus (FRAME_XIC (f
));
10022 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
10023 instructs the WM to set the input focus automatically for
10024 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
10025 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
10026 it has set the focus. So, XSetInputFocus below is not
10029 The call to XSetInputFocus below has also caused trouble. In
10030 cases where the XSetInputFocus done by the WM and the one
10031 below are temporally close (on a fast machine), the call
10032 below can generate additional FocusIn events which confuse
10035 /* Since we set WM_TAKE_FOCUS, we must call
10036 XSetInputFocus explicitly. But not if f is null,
10037 since that might be an event for a deleted frame. */
10040 Display
*d
= event
.xclient
.display
;
10041 /* Catch and ignore errors, in case window has been
10042 iconified by a window manager such as GWM. */
10043 int count
= x_catch_errors (d
);
10044 XSetInputFocus (d
, event
.xclient
.window
,
10045 /* The ICCCM says this is
10046 the only valid choice. */
10048 event
.xclient
.data
.l
[1]);
10049 /* This is needed to detect the error
10050 if there is an error. */
10052 x_uncatch_errors (d
, count
);
10054 /* Not certain about handling scroll bars here */
10057 else if (event
.xclient
.data
.l
[0]
10058 == dpyinfo
->Xatom_wm_save_yourself
)
10060 /* Save state modify the WM_COMMAND property to
10061 something which can reinstate us. This notifies
10062 the session manager, who's looking for such a
10063 PropertyNotify. Can restart processing when
10064 a keyboard or mouse event arrives. */
10065 /* If we have a session manager, don't set this.
10066 KDE will then start two Emacsen, one for the
10067 session manager and one for this. */
10070 && ! x_session_have_connection ()
10074 f
= x_top_window_to_frame (dpyinfo
,
10075 event
.xclient
.window
);
10076 /* This is just so we only give real data once
10077 for a single Emacs process. */
10078 if (f
== SELECTED_FRAME ())
10079 XSetCommand (FRAME_X_DISPLAY (f
),
10080 event
.xclient
.window
,
10081 initial_argv
, initial_argc
);
10083 XSetCommand (FRAME_X_DISPLAY (f
),
10084 event
.xclient
.window
,
10088 else if (event
.xclient
.data
.l
[0]
10089 == dpyinfo
->Xatom_wm_delete_window
)
10092 = x_any_window_to_frame (dpyinfo
,
10093 event
.xclient
.window
);
10100 bufp
->kind
= delete_window_event
;
10101 XSETFRAME (bufp
->frame_or_window
, f
);
10110 else if (event
.xclient
.message_type
10111 == dpyinfo
->Xatom_wm_configure_denied
)
10114 else if (event
.xclient
.message_type
10115 == dpyinfo
->Xatom_wm_window_moved
)
10119 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
10121 new_x
= event
.xclient
.data
.s
[0];
10122 new_y
= event
.xclient
.data
.s
[1];
10126 f
->output_data
.x
->left_pos
= new_x
;
10127 f
->output_data
.x
->top_pos
= new_y
;
10130 #ifdef HACK_EDITRES
10131 else if (event
.xclient
.message_type
10132 == dpyinfo
->Xatom_editres
)
10135 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
10136 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
10139 #endif /* HACK_EDITRES */
10140 else if ((event
.xclient
.message_type
10141 == dpyinfo
->Xatom_DONE
)
10142 || (event
.xclient
.message_type
10143 == dpyinfo
->Xatom_PAGE
))
10145 /* Ghostview job completed. Kill it. We could
10146 reply with "Next" if we received "Page", but we
10147 currently never do because we are interested in
10148 images, only, which should have 1 page. */
10149 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
10151 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
10152 x_kill_gs_process (pixmap
, f
);
10153 expose_frame (f
, 0, 0, 0, 0);
10155 #ifdef USE_TOOLKIT_SCROLL_BARS
10156 /* Scroll bar callbacks send a ClientMessage from which
10157 we construct an input_event. */
10158 else if (event
.xclient
.message_type
10159 == dpyinfo
->Xatom_Scrollbar
)
10161 x_scroll_bar_to_input_event (&event
, bufp
);
10162 ++bufp
, ++count
, --numchars
;
10165 #endif /* USE_TOOLKIT_SCROLL_BARS */
10171 case SelectionNotify
:
10172 #ifdef USE_X_TOOLKIT
10173 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
10175 #endif /* not USE_X_TOOLKIT */
10176 x_handle_selection_notify (&event
.xselection
);
10179 case SelectionClear
: /* Someone has grabbed ownership. */
10180 #ifdef USE_X_TOOLKIT
10181 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
10183 #endif /* USE_X_TOOLKIT */
10185 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
10190 bufp
->kind
= selection_clear_event
;
10191 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
10192 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
10193 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
10194 bufp
->frame_or_window
= Qnil
;
10203 case SelectionRequest
: /* Someone wants our selection. */
10204 #ifdef USE_X_TOOLKIT
10205 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
10207 #endif /* USE_X_TOOLKIT */
10208 if (x_queue_selection_requests
)
10209 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
10213 XSelectionRequestEvent
*eventp
10214 = (XSelectionRequestEvent
*) &event
;
10219 bufp
->kind
= selection_request_event
;
10220 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
10221 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
10222 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
10223 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
10224 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
10225 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
10226 bufp
->frame_or_window
= Qnil
;
10235 case PropertyNotify
:
10236 #if 0 /* This is plain wrong. In the case that we are waiting for a
10237 PropertyNotify used as an ACK in incremental selection
10238 transfer, the property will be on the receiver's window. */
10239 #if defined USE_X_TOOLKIT
10240 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
10244 x_handle_property_notify (&event
.xproperty
);
10247 case ReparentNotify
:
10248 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
10252 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
10253 x_real_positions (f
, &x
, &y
);
10254 f
->output_data
.x
->left_pos
= x
;
10255 f
->output_data
.x
->top_pos
= y
;
10260 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
10263 x_check_fullscreen (f
);
10265 if (f
->async_visible
== 0)
10267 f
->async_visible
= 1;
10268 f
->async_iconified
= 0;
10269 f
->output_data
.x
->has_been_visible
= 1;
10270 SET_FRAME_GARBAGED (f
);
10273 expose_frame (x_window_to_frame (dpyinfo
,
10274 event
.xexpose
.window
),
10275 event
.xexpose
.x
, event
.xexpose
.y
,
10276 event
.xexpose
.width
, event
.xexpose
.height
);
10280 #ifndef USE_TOOLKIT_SCROLL_BARS
10281 struct scroll_bar
*bar
;
10283 #if defined USE_LUCID
10284 /* Submenus of the Lucid menu bar aren't widgets
10285 themselves, so there's no way to dispatch events
10286 to them. Recognize this case separately. */
10289 = x_window_to_menu_bar (event
.xexpose
.window
);
10291 xlwmenu_redisplay (widget
);
10293 #endif /* USE_LUCID */
10295 #ifdef USE_TOOLKIT_SCROLL_BARS
10296 /* Dispatch event to the widget. */
10298 #else /* not USE_TOOLKIT_SCROLL_BARS */
10299 bar
= x_window_to_scroll_bar (event
.xexpose
.window
);
10302 x_scroll_bar_expose (bar
, &event
);
10303 #ifdef USE_X_TOOLKIT
10306 #endif /* USE_X_TOOLKIT */
10307 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10311 case GraphicsExpose
: /* This occurs when an XCopyArea's
10312 source area was obscured or not
10314 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
10318 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
10319 event
.xgraphicsexpose
.width
,
10320 event
.xgraphicsexpose
.height
);
10322 #ifdef USE_X_TOOLKIT
10325 #endif /* USE_X_TOOLKIT */
10328 case NoExpose
: /* This occurs when an XCopyArea's
10329 source area was completely
10334 /* Redo the mouse-highlight after the tooltip has gone. */
10335 if (event
.xmap
.window
== tip_window
)
10338 redo_mouse_highlight ();
10341 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
10342 if (f
) /* F may no longer exist if
10343 the frame was deleted. */
10345 /* While a frame is unmapped, display generation is
10346 disabled; you don't want to spend time updating a
10347 display that won't ever be seen. */
10348 f
->async_visible
= 0;
10349 /* We can't distinguish, from the event, whether the window
10350 has become iconified or invisible. So assume, if it
10351 was previously visible, than now it is iconified.
10352 But x_make_frame_invisible clears both
10353 the visible flag and the iconified flag;
10354 and that way, we know the window is not iconified now. */
10355 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
10357 f
->async_iconified
= 1;
10359 bufp
->kind
= iconify_event
;
10360 XSETFRAME (bufp
->frame_or_window
, f
);
10370 if (event
.xmap
.window
== tip_window
)
10371 /* The tooltip has been drawn already. Avoid
10372 the SET_FRAME_GARBAGED below. */
10375 /* We use x_top_window_to_frame because map events can
10376 come for sub-windows and they don't mean that the
10377 frame is visible. */
10378 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
10381 f
->async_visible
= 1;
10382 f
->async_iconified
= 0;
10383 f
->output_data
.x
->has_been_visible
= 1;
10385 /* wait_reading_process_input will notice this and update
10386 the frame's display structures. */
10387 SET_FRAME_GARBAGED (f
);
10391 bufp
->kind
= deiconify_event
;
10392 XSETFRAME (bufp
->frame_or_window
, f
);
10398 else if (! NILP (Vframe_list
)
10399 && ! NILP (XCDR (Vframe_list
)))
10400 /* Force a redisplay sooner or later
10401 to update the frame titles
10402 in case this is the second frame. */
10403 record_asynch_buffer_change ();
10409 /* Dispatch KeyPress events when in menu. */
10410 if (popup_activated_flag
)
10413 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
10415 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
10417 dpyinfo
->mouse_face_hidden
= 1;
10418 clear_mouse_face (dpyinfo
);
10421 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
10424 /* Scroll bars consume key events, but we want
10425 the keys to go to the scroll bar's frame. */
10426 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
10427 event
.xkey
.window
);
10428 if (widget
&& XmIsScrollBar (widget
))
10430 widget
= XtParent (widget
);
10431 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
10434 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
10438 KeySym keysym
, orig_keysym
;
10439 /* al%imercury@uunet.uu.net says that making this 81
10440 instead of 80 fixed a bug whereby meta chars made
10443 It seems that some version of XmbLookupString has
10444 a bug of not returning XBufferOverflow in
10445 status_return even if the input is too long to
10446 fit in 81 bytes. So, we must prepare sufficient
10447 bytes for copy_buffer. 513 bytes (256 chars for
10448 two-byte character set) seems to be a fairly good
10449 approximation. -- 2000.8.10 handa@etl.go.jp */
10450 unsigned char copy_buffer
[513];
10451 unsigned char *copy_bufptr
= copy_buffer
;
10452 int copy_bufsiz
= sizeof (copy_buffer
);
10454 Lisp_Object coding_system
= Qlatin_1
;
10457 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
10458 extra_keyboard_modifiers
);
10459 modifiers
= event
.xkey
.state
;
10461 /* This will have to go some day... */
10463 /* make_lispy_event turns chars into control chars.
10464 Don't do it here because XLookupString is too eager. */
10465 event
.xkey
.state
&= ~ControlMask
;
10466 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
10467 | dpyinfo
->super_mod_mask
10468 | dpyinfo
->hyper_mod_mask
10469 | dpyinfo
->alt_mod_mask
);
10471 /* In case Meta is ComposeCharacter,
10472 clear its status. According to Markus Ehrnsperger
10473 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
10474 this enables ComposeCharacter to work whether or
10475 not it is combined with Meta. */
10476 if (modifiers
& dpyinfo
->meta_mod_mask
)
10477 bzero (&compose_status
, sizeof (compose_status
));
10482 Status status_return
;
10484 coding_system
= Vlocale_coding_system
;
10485 nbytes
= XmbLookupString (FRAME_XIC (f
),
10486 &event
.xkey
, copy_bufptr
,
10487 copy_bufsiz
, &keysym
,
10489 if (status_return
== XBufferOverflow
)
10491 copy_bufsiz
= nbytes
+ 1;
10492 copy_bufptr
= (char *) alloca (copy_bufsiz
);
10493 nbytes
= XmbLookupString (FRAME_XIC (f
),
10494 &event
.xkey
, copy_bufptr
,
10495 copy_bufsiz
, &keysym
,
10498 #ifdef X_HAVE_UTF8_STRING
10499 else if (status_return
== XLookupKeySym
)
10500 { /* Try again but with utf-8. */
10501 coding_system
= Qutf_8
;
10502 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
10503 &event
.xkey
, copy_bufptr
,
10504 copy_bufsiz
, &keysym
,
10506 if (status_return
== XBufferOverflow
)
10508 copy_bufsiz
= nbytes
+ 1;
10509 copy_bufptr
= (char *) alloca (copy_bufsiz
);
10510 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
10513 copy_bufsiz
, &keysym
,
10519 if (status_return
== XLookupNone
)
10521 else if (status_return
== XLookupChars
)
10526 else if (status_return
!= XLookupKeySym
10527 && status_return
!= XLookupBoth
)
10531 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
10532 copy_bufsiz
, &keysym
,
10535 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
10536 copy_bufsiz
, &keysym
,
10540 orig_keysym
= keysym
;
10544 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
10545 || keysym
== XK_Delete
10546 #ifdef XK_ISO_Left_Tab
10547 || (keysym
>= XK_ISO_Left_Tab
&& keysym
<= XK_ISO_Enter
)
10549 || (keysym
>= XK_Kanji
&& keysym
<= XK_Eisu_toggle
)
10550 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
10551 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
10553 /* This recognizes the "extended function keys".
10554 It seems there's no cleaner way.
10555 Test IsModifierKey to avoid handling mode_switch
10557 || ((unsigned) (keysym
) >= XK_Select
10558 && (unsigned)(keysym
) < XK_KP_Space
)
10560 #ifdef XK_dead_circumflex
10561 || orig_keysym
== XK_dead_circumflex
10563 #ifdef XK_dead_grave
10564 || orig_keysym
== XK_dead_grave
10566 #ifdef XK_dead_tilde
10567 || orig_keysym
== XK_dead_tilde
10569 #ifdef XK_dead_diaeresis
10570 || orig_keysym
== XK_dead_diaeresis
10572 #ifdef XK_dead_macron
10573 || orig_keysym
== XK_dead_macron
10575 #ifdef XK_dead_degree
10576 || orig_keysym
== XK_dead_degree
10578 #ifdef XK_dead_acute
10579 || orig_keysym
== XK_dead_acute
10581 #ifdef XK_dead_cedilla
10582 || orig_keysym
== XK_dead_cedilla
10584 #ifdef XK_dead_breve
10585 || orig_keysym
== XK_dead_breve
10587 #ifdef XK_dead_ogonek
10588 || orig_keysym
== XK_dead_ogonek
10590 #ifdef XK_dead_caron
10591 || orig_keysym
== XK_dead_caron
10593 #ifdef XK_dead_doubleacute
10594 || orig_keysym
== XK_dead_doubleacute
10596 #ifdef XK_dead_abovedot
10597 || orig_keysym
== XK_dead_abovedot
10599 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
10600 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
10601 /* Any "vendor-specific" key is ok. */
10602 || (orig_keysym
& (1 << 28))
10603 || (keysym
!= NoSymbol
&& nbytes
== 0))
10604 && ! (IsModifierKey (orig_keysym
)
10606 #ifdef XK_Mode_switch
10607 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
10610 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
10612 #endif /* not HAVE_X11R5 */
10613 /* The symbols from XK_ISO_Lock to
10614 XK_ISO_Last_Group_Lock doesn't have real
10615 modifiers but should be treated similarly
10616 to Mode_switch by Emacs. */
10617 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
10618 || ((unsigned)(orig_keysym
) >= XK_ISO_Lock
10619 && (unsigned)(orig_keysym
) <= XK_ISO_Last_Group_Lock
)
10623 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
10625 temp_buffer
[temp_index
++] = keysym
;
10626 bufp
->kind
= non_ascii_keystroke
;
10627 bufp
->code
= keysym
;
10628 XSETFRAME (bufp
->frame_or_window
, f
);
10631 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
10633 bufp
->timestamp
= event
.xkey
.time
;
10638 else if (numchars
> nbytes
)
10644 /* The input should be decoded with `coding_system'
10645 which depends on which X*LookupString function
10646 we used just above and the locale. */
10647 setup_coding_system (coding_system
, &coding
);
10648 coding
.src_multibyte
= 0;
10649 coding
.dst_multibyte
= 1;
10650 /* The input is converted to events, thus we can't
10651 handle composition. Anyway, there's no XIM that
10652 gives us composition information. */
10653 coding
.composing
= COMPOSITION_DISABLED
;
10655 for (i
= 0; i
< nbytes
; i
++)
10657 if (temp_index
== (sizeof temp_buffer
10660 temp_buffer
[temp_index
++] = copy_bufptr
[i
];
10664 /* Decode the input data. */
10668 require
= decoding_buffer_size (&coding
, nbytes
);
10669 p
= (unsigned char *) alloca (require
);
10670 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
10671 decode_coding (&coding
, copy_bufptr
, p
,
10673 nbytes
= coding
.produced
;
10674 nchars
= coding
.produced_char
;
10678 /* Convert the input data to a sequence of
10679 character events. */
10680 for (i
= 0; i
< nbytes
; i
+= len
)
10682 if (nchars
== nbytes
)
10683 c
= copy_bufptr
[i
], len
= 1;
10685 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
10688 bufp
->kind
= (SINGLE_BYTE_CHAR_P (c
)
10690 : multibyte_char_keystroke
);
10692 XSETFRAME (bufp
->frame_or_window
, f
);
10695 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
10697 bufp
->timestamp
= event
.xkey
.time
;
10702 numchars
-= nchars
;
10704 if (keysym
== NoSymbol
)
10714 /* Don't dispatch this event since XtDispatchEvent calls
10715 XFilterEvent, and two calls in a row may freeze the
10724 /* Don't dispatch this event since XtDispatchEvent calls
10725 XFilterEvent, and two calls in a row may freeze the
10732 /* Here's a possible interpretation of the whole
10733 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If
10734 you get a FocusIn event, you have to get a FocusOut
10735 event before you relinquish the focus. If you
10736 haven't received a FocusIn event, then a mere
10737 LeaveNotify is enough to free you. */
10741 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10744 if (event
.xcrossing
.focus
)
10746 /* Avoid nasty pop/raise loops. */
10747 if (f
&& (!(f
->auto_raise
)
10748 || !(f
->auto_lower
)
10749 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
10751 x_new_focus_frame (dpyinfo
, f
);
10752 enter_timestamp
= event
.xcrossing
.time
;
10755 else if (f
== dpyinfo
->x_focus_frame
)
10756 x_new_focus_frame (dpyinfo
, 0);
10759 /* EnterNotify counts as mouse movement,
10760 so update things that depend on mouse position. */
10761 if (f
&& !f
->output_data
.x
->hourglass_p
)
10762 note_mouse_movement (f
, &event
.xmotion
);
10767 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
10768 if (event
.xfocus
.detail
!= NotifyPointer
)
10769 dpyinfo
->x_focus_event_frame
= f
;
10772 x_new_focus_frame (dpyinfo
, f
);
10774 /* Don't stop displaying the initial startup message
10775 for a switch-frame event we don't need. */
10776 if (GC_NILP (Vterminal_frame
)
10777 && GC_CONSP (Vframe_list
)
10778 && !GC_NILP (XCDR (Vframe_list
)))
10780 bufp
->kind
= FOCUS_IN_EVENT
;
10781 XSETFRAME (bufp
->frame_or_window
, f
);
10783 ++bufp
, ++count
, --numchars
;
10788 if (f
&& FRAME_XIC (f
))
10789 XSetICFocus (FRAME_XIC (f
));
10795 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10798 if (f
== dpyinfo
->mouse_face_mouse_frame
)
10800 /* If we move outside the frame, then we're
10801 certainly no longer on any text in the frame. */
10802 clear_mouse_face (dpyinfo
);
10803 dpyinfo
->mouse_face_mouse_frame
= 0;
10806 /* Generate a nil HELP_EVENT to cancel a help-echo.
10807 Do it only if there's something to cancel.
10808 Otherwise, the startup message is cleared when
10809 the mouse leaves the frame. */
10810 if (any_help_event_p
)
10815 XSETFRAME (frame
, f
);
10817 n
= gen_help_event (bufp
, numchars
,
10818 Qnil
, frame
, Qnil
, Qnil
, 0);
10819 bufp
+= n
, count
+= n
, numchars
-= n
;
10823 if (event
.xcrossing
.focus
)
10824 x_mouse_leave (dpyinfo
);
10827 if (f
== dpyinfo
->x_focus_event_frame
)
10828 dpyinfo
->x_focus_event_frame
= 0;
10829 if (f
== dpyinfo
->x_focus_frame
)
10830 x_new_focus_frame (dpyinfo
, 0);
10837 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
10838 if (event
.xfocus
.detail
!= NotifyPointer
10839 && f
== dpyinfo
->x_focus_event_frame
)
10840 dpyinfo
->x_focus_event_frame
= 0;
10841 if (f
&& f
== dpyinfo
->x_focus_frame
)
10842 x_new_focus_frame (dpyinfo
, 0);
10845 if (f
&& FRAME_XIC (f
))
10846 XUnsetICFocus (FRAME_XIC (f
));
10853 previous_help_echo
= help_echo
;
10854 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
10855 help_echo_pos
= -1;
10857 if (dpyinfo
->grabbed
&& last_mouse_frame
10858 && FRAME_LIVE_P (last_mouse_frame
))
10859 f
= last_mouse_frame
;
10861 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
10863 if (dpyinfo
->mouse_face_hidden
)
10865 dpyinfo
->mouse_face_hidden
= 0;
10866 clear_mouse_face (dpyinfo
);
10872 /* Generate SELECT_WINDOW_EVENTs when needed. */
10873 if (mouse_autoselect_window
)
10875 Lisp_Object window
;
10878 window
= window_from_coordinates (f
,
10879 event
.xmotion
.x
, event
.xmotion
.y
,
10882 /* Window will be selected only when it is not selected now and
10883 last mouse movement event was not in it. Minibuffer window
10884 will be selected iff it is active. */
10885 if (WINDOWP(window
)
10886 && !EQ (window
, last_window
)
10887 && !EQ (window
, selected_window
)
10890 bufp
->kind
= SELECT_WINDOW_EVENT
;
10891 bufp
->frame_or_window
= window
;
10893 ++bufp
, ++count
, --numchars
;
10896 last_window
=window
;
10898 note_mouse_movement (f
, &event
.xmotion
);
10902 #ifndef USE_TOOLKIT_SCROLL_BARS
10903 struct scroll_bar
*bar
10904 = x_window_to_scroll_bar (event
.xmotion
.window
);
10907 x_scroll_bar_note_movement (bar
, &event
);
10908 #endif /* USE_TOOLKIT_SCROLL_BARS */
10910 /* If we move outside the frame, then we're
10911 certainly no longer on any text in the frame. */
10912 clear_mouse_face (dpyinfo
);
10915 /* If the contents of the global variable help_echo
10916 has changed, generate a HELP_EVENT. */
10917 if (!NILP (help_echo
)
10918 || !NILP (previous_help_echo
))
10924 XSETFRAME (frame
, f
);
10928 any_help_event_p
= 1;
10929 n
= gen_help_event (bufp
, numchars
, help_echo
, frame
,
10930 help_echo_window
, help_echo_object
,
10932 bufp
+= n
, count
+= n
, numchars
-= n
;
10938 case ConfigureNotify
:
10939 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
10942 #ifndef USE_X_TOOLKIT
10943 /* If there is a pending resize for fullscreen, don't
10944 do this one, the right one will come later.
10945 The toolkit version doesn't seem to need this, but we
10946 need to reset it below. */
10948 ((f
->output_data
.x
->want_fullscreen
& FULLSCREEN_WAIT
)
10949 && FRAME_NEW_WIDTH (f
) != 0);
10950 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
10951 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
10955 /* In the toolkit version, change_frame_size
10956 is called by the code that handles resizing
10957 of the EmacsFrame widget. */
10959 /* Even if the number of character rows and columns has
10960 not changed, the font size may have changed, so we need
10961 to check the pixel dimensions as well. */
10962 if (columns
!= f
->width
10963 || rows
!= f
->height
10964 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
10965 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
10967 change_frame_size (f
, rows
, columns
, 0, 1, 0);
10968 SET_FRAME_GARBAGED (f
);
10969 cancel_mouse_face (f
);
10973 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
10974 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
10976 /* What we have now is the position of Emacs's own window.
10977 Convert that to the position of the window manager window. */
10978 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
10979 &f
->output_data
.x
->top_pos
);
10981 x_check_fullscreen_move(f
);
10982 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_WAIT
)
10983 f
->output_data
.x
->want_fullscreen
&=
10984 ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
10986 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
10987 xic_set_statusarea (f
);
10990 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
10992 /* Since the WM decorations come below top_pos now,
10993 we must put them below top_pos in the future. */
10994 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
10995 x_wm_set_size_hint (f
, (long) 0, 0);
10998 /* Some window managers pass (0,0) as the location of
10999 the window, and the Motif event handler stores it
11000 in the emacs widget, which messes up Motif menus. */
11001 if (event
.xconfigure
.x
== 0 && event
.xconfigure
.y
== 0)
11003 event
.xconfigure
.x
= f
->output_data
.x
->widget
->core
.x
;
11004 event
.xconfigure
.y
= f
->output_data
.x
->widget
->core
.y
;
11006 #endif /* USE_MOTIF */
11011 case ButtonRelease
:
11013 /* If we decide we want to generate an event to be seen
11014 by the rest of Emacs, we put it here. */
11015 struct input_event emacs_event
;
11016 int tool_bar_p
= 0;
11018 emacs_event
.kind
= no_event
;
11019 bzero (&compose_status
, sizeof (compose_status
));
11021 if (dpyinfo
->grabbed
11022 && last_mouse_frame
11023 && FRAME_LIVE_P (last_mouse_frame
))
11024 f
= last_mouse_frame
;
11026 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
11030 /* Is this in the tool-bar? */
11031 if (WINDOWP (f
->tool_bar_window
)
11032 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
11034 Lisp_Object window
;
11037 x
= event
.xbutton
.x
;
11038 y
= event
.xbutton
.y
;
11041 window
= window_from_coordinates (f
, x
, y
, &p
, 1);
11042 if (EQ (window
, f
->tool_bar_window
))
11044 x_handle_tool_bar_click (f
, &event
.xbutton
);
11050 if (!dpyinfo
->x_focus_frame
11051 || f
== dpyinfo
->x_focus_frame
)
11052 construct_mouse_click (&emacs_event
, &event
, f
);
11056 #ifndef USE_TOOLKIT_SCROLL_BARS
11057 struct scroll_bar
*bar
11058 = x_window_to_scroll_bar (event
.xbutton
.window
);
11061 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
11062 #endif /* not USE_TOOLKIT_SCROLL_BARS */
11065 if (event
.type
== ButtonPress
)
11067 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
11068 last_mouse_frame
= f
;
11069 /* Ignore any mouse motion that happened
11070 before this event; any subsequent mouse-movement
11071 Emacs events should reflect only motion after
11072 the ButtonPress. */
11074 f
->mouse_moved
= 0;
11077 last_tool_bar_item
= -1;
11081 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
11084 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
11086 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
11092 #ifdef USE_X_TOOLKIT
11093 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
11094 /* For a down-event in the menu bar,
11095 don't pass it to Xt right now.
11096 Instead, save it away
11097 and we will pass it to Xt from kbd_buffer_get_event.
11098 That way, we can run some Lisp code first. */
11099 if (f
&& event
.type
== ButtonPress
11100 /* Verify the event is really within the menu bar
11101 and not just sent to it due to grabbing. */
11102 && event
.xbutton
.x
>= 0
11103 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
11104 && event
.xbutton
.y
>= 0
11105 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
11106 && event
.xbutton
.same_screen
)
11108 SET_SAVED_BUTTON_EVENT
;
11109 XSETFRAME (last_mouse_press_frame
, f
);
11111 else if (event
.type
== ButtonPress
)
11113 last_mouse_press_frame
= Qnil
;
11117 #ifdef USE_MOTIF /* This should do not harm for Lucid,
11118 but I am trying to be cautious. */
11119 else if (event
.type
== ButtonRelease
)
11121 if (!NILP (last_mouse_press_frame
))
11123 f
= XFRAME (last_mouse_press_frame
);
11124 if (f
->output_data
.x
)
11125 SET_SAVED_BUTTON_EVENT
;
11130 #endif /* USE_MOTIF */
11133 #endif /* USE_X_TOOLKIT */
11137 case CirculateNotify
:
11140 case CirculateRequest
:
11143 case VisibilityNotify
:
11146 case MappingNotify
:
11147 /* Someone has changed the keyboard mapping - update the
11149 switch (event
.xmapping
.request
)
11151 case MappingModifier
:
11152 x_find_modifier_meanings (dpyinfo
);
11153 /* This is meant to fall through. */
11154 case MappingKeyboard
:
11155 XRefreshKeyboardMapping (&event
.xmapping
);
11161 #ifdef USE_X_TOOLKIT
11163 XtDispatchEvent (&event
);
11165 #endif /* USE_X_TOOLKIT */
11173 /* On some systems, an X bug causes Emacs to get no more events
11174 when the window is destroyed. Detect that. (1994.) */
11177 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
11178 One XNOOP in 100 loops will make Emacs terminate.
11179 B. Bretthauer, 1994 */
11181 if (x_noop_count
>= 100)
11185 if (next_noop_dpyinfo
== 0)
11186 next_noop_dpyinfo
= x_display_list
;
11188 XNoOp (next_noop_dpyinfo
->display
);
11190 /* Each time we get here, cycle through the displays now open. */
11191 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
11195 /* If the focus was just given to an auto-raising frame,
11197 /* ??? This ought to be able to handle more than one such frame. */
11198 if (pending_autoraise_frame
)
11200 x_raise_frame (pending_autoraise_frame
);
11201 pending_autoraise_frame
= 0;
11212 /***********************************************************************
11214 ***********************************************************************/
11216 /* Notice when the text cursor of window W has been completely
11217 overwritten by a drawing operation that outputs glyphs in AREA
11218 starting at X0 and ending at X1 in the line starting at Y0 and
11219 ending at Y1. X coordinates are area-relative. X1 < 0 means all
11220 the rest of the line after X0 has been written. Y coordinates
11221 are window-relative. */
11224 notice_overwritten_cursor (w
, area
, x0
, x1
, y0
, y1
)
11226 enum glyph_row_area area
;
11227 int x0
, y0
, x1
, y1
;
11229 if (area
== TEXT_AREA
&& w
->phys_cursor_on_p
)
11231 int cx0
= w
->phys_cursor
.x
;
11232 int cx1
= cx0
+ w
->phys_cursor_width
;
11233 int cy0
= w
->phys_cursor
.y
;
11234 int cy1
= cy0
+ w
->phys_cursor_height
;
11236 if (x0
<= cx0
&& (x1
< 0 || x1
>= cx1
))
11238 /* The cursor image will be completely removed from the
11239 screen if the output area intersects the cursor area in
11240 y-direction. When we draw in [y0 y1[, and some part of
11241 the cursor is at y < y0, that part must have been drawn
11242 before. When scrolling, the cursor is erased before
11243 actually scrolling, so we don't come here. When not
11244 scrolling, the rows above the old cursor row must have
11245 changed, and in this case these rows must have written
11246 over the cursor image.
11248 Likewise if part of the cursor is below y1, with the
11249 exception of the cursor being in the first blank row at
11250 the buffer and window end because update_text_area
11251 doesn't draw that row. */
11252 if (((y0
>= cy0
&& y0
< cy1
) || (y1
> cy0
&& y1
< cy1
))
11253 && w
->current_matrix
->rows
[w
->phys_cursor
.vpos
].displays_text_p
)
11254 w
->phys_cursor_on_p
= 0;
11260 /* Set clipping for output in glyph row ROW. W is the window in which
11261 we operate. GC is the graphics context to set clipping in.
11262 WHOLE_LINE_P non-zero means include the areas used for truncation
11263 mark display and alike in the clipping rectangle.
11265 ROW may be a text row or, e.g., a mode line. Text rows must be
11266 clipped to the interior of the window dedicated to text display,
11267 mode lines must be clipped to the whole window. */
11270 x_clip_to_row (w
, row
, gc
, whole_line_p
)
11272 struct glyph_row
*row
;
11276 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
11277 XRectangle clip_rect
;
11278 int window_x
, window_y
, window_width
, window_height
;
11280 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
11282 clip_rect
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
11283 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
11284 clip_rect
.y
= max (clip_rect
.y
, window_y
);
11285 clip_rect
.width
= window_width
;
11286 clip_rect
.height
= row
->visible_height
;
11288 /* If clipping to the whole line, including trunc marks, extend
11289 the rectangle to the left and increase its width. */
11292 clip_rect
.x
-= FRAME_X_LEFT_FRINGE_WIDTH (f
);
11293 clip_rect
.width
+= FRAME_X_FRINGE_WIDTH (f
);
11296 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
11300 /* Draw a hollow box cursor on window W in glyph row ROW. */
11303 x_draw_hollow_cursor (w
, row
)
11305 struct glyph_row
*row
;
11307 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
11308 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11309 Display
*dpy
= FRAME_X_DISPLAY (f
);
11312 struct glyph
*cursor_glyph
;
11315 /* Compute frame-relative coordinates from window-relative
11317 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
11318 y
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
11319 + row
->ascent
- w
->phys_cursor_ascent
);
11320 h
= row
->height
- 1;
11322 /* Get the glyph the cursor is on. If we can't tell because
11323 the current matrix is invalid or such, give up. */
11324 cursor_glyph
= get_phys_cursor_glyph (w
);
11325 if (cursor_glyph
== NULL
)
11328 /* Compute the width of the rectangle to draw. If on a stretch
11329 glyph, and `x-stretch-block-cursor' is nil, don't draw a
11330 rectangle as wide as the glyph, but use a canonical character
11332 wd
= cursor_glyph
->pixel_width
- 1;
11333 if (cursor_glyph
->type
== STRETCH_GLYPH
11334 && !x_stretch_cursor_p
)
11335 wd
= min (CANON_X_UNIT (f
), wd
);
11336 w
->phys_cursor_width
= wd
;
11338 /* The foreground of cursor_gc is typically the same as the normal
11339 background color, which can cause the cursor box to be invisible. */
11340 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
11341 if (dpyinfo
->scratch_cursor_gc
)
11342 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
11344 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
11345 GCForeground
, &xgcv
);
11346 gc
= dpyinfo
->scratch_cursor_gc
;
11348 /* Set clipping, draw the rectangle, and reset clipping again. */
11349 x_clip_to_row (w
, row
, gc
, 0);
11350 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
11351 XSetClipMask (dpy
, gc
, None
);
11355 /* Draw a bar cursor on window W in glyph row ROW.
11357 Implementation note: One would like to draw a bar cursor with an
11358 angle equal to the one given by the font property XA_ITALIC_ANGLE.
11359 Unfortunately, I didn't find a font yet that has this property set.
11363 x_draw_bar_cursor (w
, row
, width
, kind
)
11365 struct glyph_row
*row
;
11367 enum text_cursor_kinds kind
;
11369 struct frame
*f
= XFRAME (w
->frame
);
11370 struct glyph
*cursor_glyph
;
11372 /* If cursor is out of bounds, don't draw garbage. This can happen
11373 in mini-buffer windows when switching between echo area glyphs
11374 and mini-buffer. */
11375 cursor_glyph
= get_phys_cursor_glyph (w
);
11376 if (cursor_glyph
== NULL
)
11379 /* If on an image, draw like a normal cursor. That's usually better
11380 visible than drawing a bar, esp. if the image is large so that
11381 the bar might not be in the window. */
11382 if (cursor_glyph
->type
== IMAGE_GLYPH
)
11384 struct glyph_row
*row
;
11385 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
11386 x_draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
11390 Display
*dpy
= FRAME_X_DISPLAY (f
);
11391 Window window
= FRAME_X_WINDOW (f
);
11392 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
11393 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
11394 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
11397 /* If the glyph's background equals the color we normally draw
11398 the bar cursor in, the bar cursor in its normal color is
11399 invisible. Use the glyph's foreground color instead in this
11400 case, on the assumption that the glyph's colors are chosen so
11401 that the glyph is legible. */
11402 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
11403 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
11405 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
11406 xgcv
.graphics_exposures
= 0;
11409 XChangeGC (dpy
, gc
, mask
, &xgcv
);
11412 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
11413 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
11417 width
= f
->output_data
.x
->cursor_width
;
11418 width
= min (cursor_glyph
->pixel_width
, width
);
11420 w
->phys_cursor_width
= width
;
11421 x_clip_to_row (w
, row
, gc
, 0);
11423 if (kind
== BAR_CURSOR
)
11424 XFillRectangle (dpy
, window
, gc
,
11425 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
11426 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
11427 width
, row
->height
);
11429 XFillRectangle (dpy
, window
, gc
,
11430 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
11431 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
11432 row
->height
- width
),
11433 cursor_glyph
->pixel_width
,
11436 XSetClipMask (dpy
, gc
, None
);
11441 /* Clear the cursor of window W to background color, and mark the
11442 cursor as not shown. This is used when the text where the cursor
11443 is is about to be rewritten. */
11449 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
11450 x_update_window_cursor (w
, 0);
11454 /* Draw the cursor glyph of window W in glyph row ROW. See the
11455 comment of x_draw_glyphs for the meaning of HL. */
11458 x_draw_phys_cursor_glyph (w
, row
, hl
)
11460 struct glyph_row
*row
;
11461 enum draw_glyphs_face hl
;
11463 /* If cursor hpos is out of bounds, don't draw garbage. This can
11464 happen in mini-buffer windows when switching between echo area
11465 glyphs and mini-buffer. */
11466 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
11468 int on_p
= w
->phys_cursor_on_p
;
11470 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
11471 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
11473 w
->phys_cursor_on_p
= on_p
;
11475 if (hl
== DRAW_CURSOR
)
11477 struct glyph
*cursor_glyph
= get_phys_cursor_glyph (w
);
11479 w
->phys_cursor_width
= cursor_glyph
->pixel_width
;
11482 /* When we erase the cursor, and ROW is overlapped by other
11483 rows, make sure that these overlapping parts of other rows
11485 else if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
11487 if (row
> w
->current_matrix
->rows
11488 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
11489 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
11491 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
11492 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
11493 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
11499 /* Erase the image of a cursor of window W from the screen. */
11502 x_erase_phys_cursor (w
)
11505 struct frame
*f
= XFRAME (w
->frame
);
11506 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11507 int hpos
= w
->phys_cursor
.hpos
;
11508 int vpos
= w
->phys_cursor
.vpos
;
11509 int mouse_face_here_p
= 0;
11510 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
11511 struct glyph_row
*cursor_row
;
11512 struct glyph
*cursor_glyph
;
11513 enum draw_glyphs_face hl
;
11515 /* No cursor displayed or row invalidated => nothing to do on the
11517 if (w
->phys_cursor_type
== NO_CURSOR
)
11518 goto mark_cursor_off
;
11520 /* VPOS >= active_glyphs->nrows means that window has been resized.
11521 Don't bother to erase the cursor. */
11522 if (vpos
>= active_glyphs
->nrows
)
11523 goto mark_cursor_off
;
11525 /* If row containing cursor is marked invalid, there is nothing we
11527 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
11528 if (!cursor_row
->enabled_p
)
11529 goto mark_cursor_off
;
11531 /* If row is completely invisible, don't attempt to delete a cursor which
11532 isn't there. This can happen if cursor is at top of a window, and
11533 we switch to a buffer with a header line in that window. */
11534 if (cursor_row
->visible_height
<= 0)
11535 goto mark_cursor_off
;
11537 /* This can happen when the new row is shorter than the old one.
11538 In this case, either x_draw_glyphs or clear_end_of_line
11539 should have cleared the cursor. Note that we wouldn't be
11540 able to erase the cursor in this case because we don't have a
11541 cursor glyph at hand. */
11542 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
11543 goto mark_cursor_off
;
11545 /* If the cursor is in the mouse face area, redisplay that when
11546 we clear the cursor. */
11547 if (! NILP (dpyinfo
->mouse_face_window
)
11548 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
11549 && (vpos
> dpyinfo
->mouse_face_beg_row
11550 || (vpos
== dpyinfo
->mouse_face_beg_row
11551 && hpos
>= dpyinfo
->mouse_face_beg_col
))
11552 && (vpos
< dpyinfo
->mouse_face_end_row
11553 || (vpos
== dpyinfo
->mouse_face_end_row
11554 && hpos
< dpyinfo
->mouse_face_end_col
))
11555 /* Don't redraw the cursor's spot in mouse face if it is at the
11556 end of a line (on a newline). The cursor appears there, but
11557 mouse highlighting does not. */
11558 && cursor_row
->used
[TEXT_AREA
] > hpos
)
11559 mouse_face_here_p
= 1;
11561 /* Maybe clear the display under the cursor. */
11562 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
11565 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
11567 cursor_glyph
= get_phys_cursor_glyph (w
);
11568 if (cursor_glyph
== NULL
)
11569 goto mark_cursor_off
;
11571 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
11573 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11575 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
11577 cursor_glyph
->pixel_width
,
11578 cursor_row
->visible_height
,
11582 /* Erase the cursor by redrawing the character underneath it. */
11583 if (mouse_face_here_p
)
11584 hl
= DRAW_MOUSE_FACE
;
11586 hl
= DRAW_NORMAL_TEXT
;
11587 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
11590 w
->phys_cursor_on_p
= 0;
11591 w
->phys_cursor_type
= NO_CURSOR
;
11595 /* Non-zero if physical cursor of window W is within mouse face. */
11598 cursor_in_mouse_face_p (w
)
11601 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
11602 int in_mouse_face
= 0;
11604 if (WINDOWP (dpyinfo
->mouse_face_window
)
11605 && XWINDOW (dpyinfo
->mouse_face_window
) == w
)
11607 int hpos
= w
->phys_cursor
.hpos
;
11608 int vpos
= w
->phys_cursor
.vpos
;
11610 if (vpos
>= dpyinfo
->mouse_face_beg_row
11611 && vpos
<= dpyinfo
->mouse_face_end_row
11612 && (vpos
> dpyinfo
->mouse_face_beg_row
11613 || hpos
>= dpyinfo
->mouse_face_beg_col
)
11614 && (vpos
< dpyinfo
->mouse_face_end_row
11615 || hpos
< dpyinfo
->mouse_face_end_col
11616 || dpyinfo
->mouse_face_past_end
))
11620 return in_mouse_face
;
11624 /* Display or clear cursor of window W. If ON is zero, clear the
11625 cursor. If it is non-zero, display the cursor. If ON is nonzero,
11626 where to put the cursor is specified by HPOS, VPOS, X and Y. */
11629 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
11631 int on
, hpos
, vpos
, x
, y
;
11633 struct frame
*f
= XFRAME (w
->frame
);
11634 int new_cursor_type
;
11635 int new_cursor_width
;
11636 struct glyph_matrix
*current_glyphs
;
11637 struct glyph_row
*glyph_row
;
11638 struct glyph
*glyph
;
11639 int cursor_non_selected
;
11641 /* This is pointless on invisible frames, and dangerous on garbaged
11642 windows and frames; in the latter case, the frame or window may
11643 be in the midst of changing its size, and x and y may be off the
11645 if (! FRAME_VISIBLE_P (f
)
11646 || FRAME_GARBAGED_P (f
)
11647 || vpos
>= w
->current_matrix
->nrows
11648 || hpos
>= w
->current_matrix
->matrix_w
)
11651 /* If cursor is off and we want it off, return quickly. */
11652 if (!on
&& !w
->phys_cursor_on_p
)
11655 current_glyphs
= w
->current_matrix
;
11656 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
11657 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
11659 /* If cursor row is not enabled, we don't really know where to
11660 display the cursor. */
11661 if (!glyph_row
->enabled_p
)
11663 w
->phys_cursor_on_p
= 0;
11667 xassert (interrupt_input_blocked
);
11669 /* Set new_cursor_type to the cursor we want to be displayed. In a
11670 mini-buffer window, we want the cursor only to appear if we are
11671 reading input from this window. For the selected window, we want
11672 the cursor type given by the frame parameter. If explicitly
11673 marked off, draw no cursor. In all other cases, we want a hollow
11675 cursor_non_selected
11676 = !NILP (Fbuffer_local_value (Qcursor_in_non_selected_windows
,
11678 new_cursor_width
= -1;
11679 if (cursor_in_echo_area
11680 && FRAME_HAS_MINIBUF_P (f
)
11681 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
11683 if (w
== XWINDOW (echo_area_window
))
11684 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
11685 else if (cursor_non_selected
)
11686 new_cursor_type
= HOLLOW_BOX_CURSOR
;
11688 new_cursor_type
= NO_CURSOR
;
11692 if (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
11693 || w
!= XWINDOW (f
->selected_window
))
11695 if ((MINI_WINDOW_P (w
) && minibuf_level
== 0)
11696 || !cursor_non_selected
11697 || NILP (XBUFFER (w
->buffer
)->cursor_type
))
11698 new_cursor_type
= NO_CURSOR
;
11700 new_cursor_type
= HOLLOW_BOX_CURSOR
;
11704 struct buffer
*b
= XBUFFER (w
->buffer
);
11706 if (EQ (b
->cursor_type
, Qt
))
11707 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
11709 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
11710 &new_cursor_width
);
11711 if (w
->cursor_off_p
)
11713 if (new_cursor_type
== FILLED_BOX_CURSOR
)
11714 new_cursor_type
= HOLLOW_BOX_CURSOR
;
11715 else if (new_cursor_type
== BAR_CURSOR
&& new_cursor_width
> 1)
11716 new_cursor_width
= 1;
11718 new_cursor_type
= NO_CURSOR
;
11723 /* If cursor is currently being shown and we don't want it to be or
11724 it is in the wrong place, or the cursor type is not what we want,
11726 if (w
->phys_cursor_on_p
11728 || w
->phys_cursor
.x
!= x
11729 || w
->phys_cursor
.y
!= y
11730 || new_cursor_type
!= w
->phys_cursor_type
11731 || (new_cursor_type
== BAR_CURSOR
11732 && new_cursor_width
!= w
->phys_cursor_width
)))
11733 x_erase_phys_cursor (w
);
11735 /* If the cursor is now invisible and we want it to be visible,
11737 if (on
&& !w
->phys_cursor_on_p
)
11739 w
->phys_cursor_ascent
= glyph_row
->ascent
;
11740 w
->phys_cursor_height
= glyph_row
->height
;
11742 /* Set phys_cursor_.* before x_draw_.* is called because some
11743 of them may need the information. */
11744 w
->phys_cursor
.x
= x
;
11745 w
->phys_cursor
.y
= glyph_row
->y
;
11746 w
->phys_cursor
.hpos
= hpos
;
11747 w
->phys_cursor
.vpos
= vpos
;
11748 w
->phys_cursor_type
= new_cursor_type
;
11749 w
->phys_cursor_on_p
= 1;
11751 switch (new_cursor_type
)
11753 case HOLLOW_BOX_CURSOR
:
11754 x_draw_hollow_cursor (w
, glyph_row
);
11757 case FILLED_BOX_CURSOR
:
11758 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
11762 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
, BAR_CURSOR
);
11766 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
, HBAR_CURSOR
);
11777 if (w
== XWINDOW (f
->selected_window
))
11778 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
11779 xic_set_preeditarea (w
, x
, y
);
11784 if (updating_frame
!= f
)
11785 XFlush (FRAME_X_DISPLAY (f
));
11790 /* Display the cursor on window W, or clear it. X and Y are window
11791 relative pixel coordinates. HPOS and VPOS are glyph matrix
11792 positions. If W is not the selected window, display a hollow
11793 cursor. ON non-zero means display the cursor at X, Y which
11794 correspond to HPOS, VPOS, otherwise it is cleared. */
11797 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
11799 int on
, hpos
, vpos
, x
, y
;
11802 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
11807 /* Display the cursor on window W, or clear it, according to ON_P.
11808 Don't change the cursor's position. */
11811 x_update_cursor (f
, on_p
)
11814 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
11818 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
11819 in the window tree rooted at W. */
11822 x_update_cursor_in_window_tree (w
, on_p
)
11828 if (!NILP (w
->hchild
))
11829 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
11830 else if (!NILP (w
->vchild
))
11831 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
11833 x_update_window_cursor (w
, on_p
);
11835 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
11840 /* Switch the display of W's cursor on or off, according to the value
11844 x_update_window_cursor (w
, on
)
11848 /* Don't update cursor in windows whose frame is in the process
11849 of being deleted. */
11850 if (w
->current_matrix
)
11853 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
11854 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
11864 /* Make the x-window of frame F use the gnu icon bitmap. */
11867 x_bitmap_icon (f
, file
)
11873 if (FRAME_X_WINDOW (f
) == 0)
11876 /* Free up our existing icon bitmap if any. */
11877 if (f
->output_data
.x
->icon_bitmap
> 0)
11878 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
11879 f
->output_data
.x
->icon_bitmap
= 0;
11881 if (STRINGP (file
))
11882 bitmap_id
= x_create_bitmap_from_file (f
, file
);
11885 /* Create the GNU bitmap if necessary. */
11886 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
11887 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
11888 = x_create_bitmap_from_data (f
, gnu_bits
,
11889 gnu_width
, gnu_height
);
11891 /* The first time we create the GNU bitmap,
11892 this increments the ref-count one extra time.
11893 As a result, the GNU bitmap is never freed.
11894 That way, we don't have to worry about allocating it again. */
11895 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
11897 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
11900 x_wm_set_icon_pixmap (f
, bitmap_id
);
11901 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
11907 /* Make the x-window of frame F use a rectangle with text.
11908 Use ICON_NAME as the text. */
11911 x_text_icon (f
, icon_name
)
11915 if (FRAME_X_WINDOW (f
) == 0)
11920 XTextProperty text
;
11921 text
.value
= (unsigned char *) icon_name
;
11922 text
.encoding
= XA_STRING
;
11924 text
.nitems
= strlen (icon_name
);
11925 #ifdef USE_X_TOOLKIT
11926 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
11928 #else /* not USE_X_TOOLKIT */
11929 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
11930 #endif /* not USE_X_TOOLKIT */
11932 #else /* not HAVE_X11R4 */
11933 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
11934 #endif /* not HAVE_X11R4 */
11936 if (f
->output_data
.x
->icon_bitmap
> 0)
11937 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
11938 f
->output_data
.x
->icon_bitmap
= 0;
11939 x_wm_set_icon_pixmap (f
, 0);
11944 #define X_ERROR_MESSAGE_SIZE 200
11946 /* If non-nil, this should be a string.
11947 It means catch X errors and store the error message in this string. */
11949 static Lisp_Object x_error_message_string
;
11951 /* An X error handler which stores the error message in
11952 x_error_message_string. This is called from x_error_handler if
11953 x_catch_errors is in effect. */
11956 x_error_catcher (display
, error
)
11958 XErrorEvent
*error
;
11960 XGetErrorText (display
, error
->error_code
,
11961 XSTRING (x_error_message_string
)->data
,
11962 X_ERROR_MESSAGE_SIZE
);
11965 /* Begin trapping X errors for display DPY. Actually we trap X errors
11966 for all displays, but DPY should be the display you are actually
11969 After calling this function, X protocol errors no longer cause
11970 Emacs to exit; instead, they are recorded in the string
11971 stored in x_error_message_string.
11973 Calling x_check_errors signals an Emacs error if an X error has
11974 occurred since the last call to x_catch_errors or x_check_errors.
11976 Calling x_uncatch_errors resumes the normal error handling. */
11978 void x_check_errors ();
11979 static Lisp_Object
x_catch_errors_unwind ();
11982 x_catch_errors (dpy
)
11985 int count
= specpdl_ptr
- specpdl
;
11987 /* Make sure any errors from previous requests have been dealt with. */
11988 XSync (dpy
, False
);
11990 record_unwind_protect (x_catch_errors_unwind
, x_error_message_string
);
11992 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
11993 XSTRING (x_error_message_string
)->data
[0] = 0;
11998 /* Unbind the binding that we made to check for X errors. */
12001 x_catch_errors_unwind (old_val
)
12002 Lisp_Object old_val
;
12004 x_error_message_string
= old_val
;
12008 /* If any X protocol errors have arrived since the last call to
12009 x_catch_errors or x_check_errors, signal an Emacs error using
12010 sprintf (a buffer, FORMAT, the x error message text) as the text. */
12013 x_check_errors (dpy
, format
)
12017 /* Make sure to catch any errors incurred so far. */
12018 XSync (dpy
, False
);
12020 if (XSTRING (x_error_message_string
)->data
[0])
12021 error (format
, XSTRING (x_error_message_string
)->data
);
12024 /* Nonzero if we had any X protocol errors
12025 since we did x_catch_errors on DPY. */
12028 x_had_errors_p (dpy
)
12031 /* Make sure to catch any errors incurred so far. */
12032 XSync (dpy
, False
);
12034 return XSTRING (x_error_message_string
)->data
[0] != 0;
12037 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
12040 x_clear_errors (dpy
)
12043 XSTRING (x_error_message_string
)->data
[0] = 0;
12046 /* Stop catching X protocol errors and let them make Emacs die.
12047 DPY should be the display that was passed to x_catch_errors.
12048 COUNT should be the value that was returned by
12049 the corresponding call to x_catch_errors. */
12052 x_uncatch_errors (dpy
, count
)
12056 unbind_to (count
, Qnil
);
12060 static unsigned int x_wire_count
;
12063 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
12068 /* Handle SIGPIPE, which can happen when the connection to a server
12069 simply goes away. SIGPIPE is handled by x_connection_signal.
12070 Don't need to do anything, because the write which caused the
12071 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
12072 which will do the appropriate cleanup for us. */
12075 x_connection_signal (signalnum
) /* If we don't have an argument, */
12076 int signalnum
; /* some compilers complain in signal calls. */
12079 /* USG systems forget handlers when they are used;
12080 must reestablish each time */
12081 signal (signalnum
, x_connection_signal
);
12086 /************************************************************************
12088 ************************************************************************/
12090 /* Error message passed to x_connection_closed. */
12092 static char *error_msg
;
12094 /* Function installed as fatal_error_signal_hook in
12095 x_connection_closed. Print the X error message, and exit normally,
12096 instead of dumping core when XtCloseDisplay fails. */
12099 x_fatal_error_signal ()
12101 fprintf (stderr
, "%s\n", error_msg
);
12105 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
12106 the text of an error message that lead to the connection loss. */
12109 x_connection_closed (dpy
, error_message
)
12111 char *error_message
;
12113 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
12114 Lisp_Object frame
, tail
;
12117 error_msg
= (char *) alloca (strlen (error_message
) + 1);
12118 strcpy (error_msg
, error_message
);
12119 handling_signal
= 0;
12121 /* Prevent being called recursively because of an error condition
12122 below. Otherwise, we might end up with printing ``can't find per
12123 display information'' in the recursive call instead of printing
12124 the original message here. */
12125 count
= x_catch_errors (dpy
);
12127 /* We have to close the display to inform Xt that it doesn't
12128 exist anymore. If we don't, Xt will continue to wait for
12129 events from the display. As a consequence, a sequence of
12131 M-x make-frame-on-display RET :1 RET
12132 ...kill the new frame, so that we get an IO error...
12133 M-x make-frame-on-display RET :1 RET
12135 will indefinitely wait in Xt for events for display `:1', opened
12136 in the first class to make-frame-on-display.
12138 Closing the display is reported to lead to a bus error on
12139 OpenWindows in certain situations. I suspect that is a bug
12140 in OpenWindows. I don't know how to cicumvent it here. */
12142 #ifdef USE_X_TOOLKIT
12143 /* If DPYINFO is null, this means we didn't open the display
12144 in the first place, so don't try to close it. */
12147 extern void (*fatal_error_signal_hook
) P_ ((void));
12148 fatal_error_signal_hook
= x_fatal_error_signal
;
12149 XtCloseDisplay (dpy
);
12150 fatal_error_signal_hook
= NULL
;
12154 /* Indicate that this display is dead. */
12156 dpyinfo
->display
= 0;
12158 /* First delete frames whose mini-buffers are on frames
12159 that are on the dead display. */
12160 FOR_EACH_FRAME (tail
, frame
)
12162 Lisp_Object minibuf_frame
;
12164 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
12165 if (FRAME_X_P (XFRAME (frame
))
12166 && FRAME_X_P (XFRAME (minibuf_frame
))
12167 && ! EQ (frame
, minibuf_frame
)
12168 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
12169 Fdelete_frame (frame
, Qt
);
12172 /* Now delete all remaining frames on the dead display.
12173 We are now sure none of these is used as the mini-buffer
12174 for another frame that we need to delete. */
12175 FOR_EACH_FRAME (tail
, frame
)
12176 if (FRAME_X_P (XFRAME (frame
))
12177 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
12179 /* Set this to t so that Fdelete_frame won't get confused
12180 trying to find a replacement. */
12181 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
12182 Fdelete_frame (frame
, Qt
);
12186 x_delete_display (dpyinfo
);
12188 x_uncatch_errors (dpy
, count
);
12190 if (x_display_list
== 0)
12192 fprintf (stderr
, "%s\n", error_msg
);
12193 shut_down_emacs (0, 0, Qnil
);
12197 /* Ordinary stack unwind doesn't deal with these. */
12199 sigunblock (sigmask (SIGIO
));
12201 sigunblock (sigmask (SIGALRM
));
12202 TOTALLY_UNBLOCK_INPUT
;
12204 clear_waiting_for_input ();
12205 error ("%s", error_msg
);
12209 /* This is the usual handler for X protocol errors.
12210 It kills all frames on the display that we got the error for.
12211 If that was the only one, it prints an error message and kills Emacs. */
12214 x_error_quitter (display
, error
)
12216 XErrorEvent
*error
;
12218 char buf
[256], buf1
[356];
12220 /* Note that there is no real way portable across R3/R4 to get the
12221 original error handler. */
12223 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
12224 sprintf (buf1
, "X protocol error: %s on protocol request %d",
12225 buf
, error
->request_code
);
12226 x_connection_closed (display
, buf1
);
12230 /* This is the first-level handler for X protocol errors.
12231 It calls x_error_quitter or x_error_catcher. */
12234 x_error_handler (display
, error
)
12236 XErrorEvent
*error
;
12238 if (! NILP (x_error_message_string
))
12239 x_error_catcher (display
, error
);
12241 x_error_quitter (display
, error
);
12245 /* This is the handler for X IO errors, always.
12246 It kills all frames on the display that we lost touch with.
12247 If that was the only one, it prints an error message and kills Emacs. */
12250 x_io_error_quitter (display
)
12255 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
12256 x_connection_closed (display
, buf
);
12260 /* Changing the font of the frame. */
12262 /* Give frame F the font named FONTNAME as its default font, and
12263 return the full name of that font. FONTNAME may be a wildcard
12264 pattern; in that case, we choose some font that fits the pattern.
12265 The return value shows which font we chose. */
12268 x_new_font (f
, fontname
)
12270 register char *fontname
;
12272 struct font_info
*fontp
12273 = FS_LOAD_FONT (f
, 0, fontname
, -1);
12278 f
->output_data
.x
->font
= (XFontStruct
*) (fontp
->font
);
12279 f
->output_data
.x
->baseline_offset
= fontp
->baseline_offset
;
12280 f
->output_data
.x
->fontset
= -1;
12282 x_compute_fringe_widths (f
, 1);
12284 /* Compute the scroll bar width in character columns. */
12285 if (f
->scroll_bar_pixel_width
> 0)
12287 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
12288 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
12292 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
12293 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
12296 /* Now make the frame display the given font. */
12297 if (FRAME_X_WINDOW (f
) != 0)
12299 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
12300 f
->output_data
.x
->font
->fid
);
12301 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
12302 f
->output_data
.x
->font
->fid
);
12303 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
12304 f
->output_data
.x
->font
->fid
);
12306 frame_update_line_height (f
);
12308 /* Don't change the size of a tip frame; there's no point in
12309 doing it because it's done in Fx_show_tip, and it leads to
12310 problems because the tip frame has no widget. */
12311 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
12312 x_set_window_size (f
, 0, f
->width
, f
->height
);
12315 /* If we are setting a new frame's font for the first time,
12316 there are no faces yet, so this font's height is the line height. */
12317 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
12319 return build_string (fontp
->full_name
);
12322 /* Give frame F the fontset named FONTSETNAME as its default font, and
12323 return the full name of that fontset. FONTSETNAME may be a wildcard
12324 pattern; in that case, we choose some fontset that fits the pattern.
12325 The return value shows which fontset we chose. */
12328 x_new_fontset (f
, fontsetname
)
12332 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
12333 Lisp_Object result
;
12338 if (f
->output_data
.x
->fontset
== fontset
)
12339 /* This fontset is already set in frame F. There's nothing more
12341 return fontset_name (fontset
);
12343 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
12345 if (!STRINGP (result
))
12346 /* Can't load ASCII font. */
12349 /* Since x_new_font doesn't update any fontset information, do it now. */
12350 f
->output_data
.x
->fontset
= fontset
;
12354 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
12355 xic_set_xfontset (f
, XSTRING (fontset_ascii (fontset
))->data
);
12358 return build_string (fontsetname
);
12361 /* Compute actual fringe widths */
12364 x_compute_fringe_widths (f
, redraw
)
12368 int o_left
= f
->output_data
.x
->left_fringe_width
;
12369 int o_right
= f
->output_data
.x
->right_fringe_width
;
12370 int o_cols
= f
->output_data
.x
->fringe_cols
;
12372 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
12373 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
12374 int left_fringe_width
, right_fringe_width
;
12376 if (!NILP (left_fringe
))
12377 left_fringe
= Fcdr (left_fringe
);
12378 if (!NILP (right_fringe
))
12379 right_fringe
= Fcdr (right_fringe
);
12381 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
12382 XINT (left_fringe
));
12383 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
12384 XINT (right_fringe
));
12386 if (left_fringe_width
|| right_fringe_width
)
12388 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
12389 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
12390 int conf_wid
= left_wid
+ right_wid
;
12391 int font_wid
= FONT_WIDTH (f
->output_data
.x
->font
);
12392 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
12393 int real_wid
= cols
* font_wid
;
12394 if (left_wid
&& right_wid
)
12396 if (left_fringe_width
< 0)
12398 /* Left fringe width is fixed, adjust right fringe if necessary */
12399 f
->output_data
.x
->left_fringe_width
= left_wid
;
12400 f
->output_data
.x
->right_fringe_width
= real_wid
- left_wid
;
12402 else if (right_fringe_width
< 0)
12404 /* Right fringe width is fixed, adjust left fringe if necessary */
12405 f
->output_data
.x
->left_fringe_width
= real_wid
- right_wid
;
12406 f
->output_data
.x
->right_fringe_width
= right_wid
;
12410 /* Adjust both fringes with an equal amount.
12411 Note that we are doing integer arithmetic here, so don't
12412 lose a pixel if the total width is an odd number. */
12413 int fill
= real_wid
- conf_wid
;
12414 f
->output_data
.x
->left_fringe_width
= left_wid
+ fill
/2;
12415 f
->output_data
.x
->right_fringe_width
= right_wid
+ fill
- fill
/2;
12418 else if (left_fringe_width
)
12420 f
->output_data
.x
->left_fringe_width
= real_wid
;
12421 f
->output_data
.x
->right_fringe_width
= 0;
12425 f
->output_data
.x
->left_fringe_width
= 0;
12426 f
->output_data
.x
->right_fringe_width
= real_wid
;
12428 f
->output_data
.x
->fringe_cols
= cols
;
12429 f
->output_data
.x
->fringes_extra
= real_wid
;
12433 f
->output_data
.x
->left_fringe_width
= 0;
12434 f
->output_data
.x
->right_fringe_width
= 0;
12435 f
->output_data
.x
->fringe_cols
= 0;
12436 f
->output_data
.x
->fringes_extra
= 0;
12439 if (redraw
&& FRAME_VISIBLE_P (f
))
12440 if (o_left
!= f
->output_data
.x
->left_fringe_width
||
12441 o_right
!= f
->output_data
.x
->right_fringe_width
||
12442 o_cols
!= f
->output_data
.x
->fringe_cols
)
12446 /***********************************************************************
12448 ***********************************************************************/
12454 /* XIM destroy callback function, which is called whenever the
12455 connection to input method XIM dies. CLIENT_DATA contains a
12456 pointer to the x_display_info structure corresponding to XIM. */
12459 xim_destroy_callback (xim
, client_data
, call_data
)
12461 XPointer client_data
;
12462 XPointer call_data
;
12464 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
12465 Lisp_Object frame
, tail
;
12469 /* No need to call XDestroyIC.. */
12470 FOR_EACH_FRAME (tail
, frame
)
12472 struct frame
*f
= XFRAME (frame
);
12473 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
12475 FRAME_XIC (f
) = NULL
;
12476 if (FRAME_XIC_FONTSET (f
))
12478 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
12479 FRAME_XIC_FONTSET (f
) = NULL
;
12484 /* No need to call XCloseIM. */
12485 dpyinfo
->xim
= NULL
;
12486 XFree (dpyinfo
->xim_styles
);
12490 #endif /* HAVE_X11R6 */
12492 /* Open the connection to the XIM server on display DPYINFO.
12493 RESOURCE_NAME is the resource name Emacs uses. */
12496 xim_open_dpy (dpyinfo
, resource_name
)
12497 struct x_display_info
*dpyinfo
;
12498 char *resource_name
;
12503 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
, EMACS_CLASS
);
12504 dpyinfo
->xim
= xim
;
12509 XIMCallback destroy
;
12512 /* Get supported styles and XIM values. */
12513 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
12516 destroy
.callback
= xim_destroy_callback
;
12517 destroy
.client_data
= (XPointer
)dpyinfo
;
12518 /* This isn't prototyped in OSF 5.0. */
12519 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
12523 #else /* not USE_XIM */
12524 dpyinfo
->xim
= NULL
;
12525 #endif /* not USE_XIM */
12529 #ifdef HAVE_X11R6_XIM
12533 struct x_display_info
*dpyinfo
;
12534 char *resource_name
;
12537 /* XIM instantiate callback function, which is called whenever an XIM
12538 server is available. DISPLAY is teh display of the XIM.
12539 CLIENT_DATA contains a pointer to an xim_inst_t structure created
12540 when the callback was registered. */
12543 xim_instantiate_callback (display
, client_data
, call_data
)
12545 XPointer client_data
;
12546 XPointer call_data
;
12548 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
12549 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
12551 /* We don't support multiple XIM connections. */
12555 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
12557 /* Create XIC for the existing frames on the same display, as long
12558 as they have no XIC. */
12559 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
12561 Lisp_Object tail
, frame
;
12564 FOR_EACH_FRAME (tail
, frame
)
12566 struct frame
*f
= XFRAME (frame
);
12568 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
12569 if (FRAME_XIC (f
) == NULL
)
12571 create_frame_xic (f
);
12572 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
12573 xic_set_statusarea (f
);
12574 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
12576 struct window
*w
= XWINDOW (f
->selected_window
);
12577 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
12586 #endif /* HAVE_X11R6_XIM */
12589 /* Open a connection to the XIM server on display DPYINFO.
12590 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
12591 connection only at the first time. On X11R6, open the connection
12592 in the XIM instantiate callback function. */
12595 xim_initialize (dpyinfo
, resource_name
)
12596 struct x_display_info
*dpyinfo
;
12597 char *resource_name
;
12600 #ifdef HAVE_X11R6_XIM
12601 struct xim_inst_t
*xim_inst
;
12604 dpyinfo
->xim
= NULL
;
12605 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
12606 xim_inst
->dpyinfo
= dpyinfo
;
12607 len
= strlen (resource_name
);
12608 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
12609 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
12610 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
12611 resource_name
, EMACS_CLASS
,
12612 xim_instantiate_callback
,
12613 /* Fixme: This is XPointer in
12614 XFree86 but (XPointer *) on
12615 Tru64, at least. */
12616 (XPointer
) xim_inst
);
12617 #else /* not HAVE_X11R6_XIM */
12618 dpyinfo
->xim
= NULL
;
12619 xim_open_dpy (dpyinfo
, resource_name
);
12620 #endif /* not HAVE_X11R6_XIM */
12622 #else /* not USE_XIM */
12623 dpyinfo
->xim
= NULL
;
12624 #endif /* not USE_XIM */
12628 /* Close the connection to the XIM server on display DPYINFO. */
12631 xim_close_dpy (dpyinfo
)
12632 struct x_display_info
*dpyinfo
;
12635 #ifdef HAVE_X11R6_XIM
12636 if (dpyinfo
->display
)
12637 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
12639 xim_instantiate_callback
, NULL
);
12640 #endif /* not HAVE_X11R6_XIM */
12641 if (dpyinfo
->display
)
12642 XCloseIM (dpyinfo
->xim
);
12643 dpyinfo
->xim
= NULL
;
12644 XFree (dpyinfo
->xim_styles
);
12645 #endif /* USE_XIM */
12648 #endif /* not HAVE_X11R6_XIM */
12652 /* Calculate the absolute position in frame F
12653 from its current recorded position values and gravity. */
12656 x_calc_absolute_position (f
)
12660 int win_x
= 0, win_y
= 0;
12661 int flags
= f
->output_data
.x
->size_hint_flags
;
12664 /* We have nothing to do if the current position
12665 is already for the top-left corner. */
12666 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
12669 #ifdef USE_X_TOOLKIT
12670 this_window
= XtWindow (f
->output_data
.x
->widget
);
12672 this_window
= FRAME_X_WINDOW (f
);
12675 /* Find the position of the outside upper-left corner of
12676 the inner window, with respect to the outer window.
12677 But do this only if we will need the results. */
12678 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
12683 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
12686 x_clear_errors (FRAME_X_DISPLAY (f
));
12687 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
12689 /* From-window, to-window. */
12691 f
->output_data
.x
->parent_desc
,
12693 /* From-position, to-position. */
12694 0, 0, &win_x
, &win_y
,
12696 /* Child of win. */
12698 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
12700 Window newroot
, newparent
= 0xdeadbeef;
12701 Window
*newchildren
;
12702 unsigned int nchildren
;
12704 if (! XQueryTree (FRAME_X_DISPLAY (f
), this_window
, &newroot
,
12705 &newparent
, &newchildren
, &nchildren
))
12708 XFree ((char *) newchildren
);
12710 f
->output_data
.x
->parent_desc
= newparent
;
12716 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
12720 /* Treat negative positions as relative to the leftmost bottommost
12721 position that fits on the screen. */
12722 if (flags
& XNegative
)
12723 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
12724 - 2 * f
->output_data
.x
->border_width
- win_x
12726 + f
->output_data
.x
->left_pos
);
12729 int height
= PIXEL_HEIGHT (f
);
12731 #if defined USE_X_TOOLKIT && defined USE_MOTIF
12732 /* Something is fishy here. When using Motif, starting Emacs with
12733 `-g -0-0', the frame appears too low by a few pixels.
12735 This seems to be so because initially, while Emacs is starting,
12736 the column widget's height and the frame's pixel height are
12737 different. The column widget's height is the right one. In
12738 later invocations, when Emacs is up, the frame's pixel height
12741 It's not obvious where the initial small difference comes from.
12742 2000-12-01, gerd. */
12744 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
12747 if (flags
& YNegative
)
12748 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
12749 - 2 * f
->output_data
.x
->border_width
12752 + f
->output_data
.x
->top_pos
);
12755 /* The left_pos and top_pos
12756 are now relative to the top and left screen edges,
12757 so the flags should correspond. */
12758 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
12761 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
12762 to really change the position, and 0 when calling from
12763 x_make_frame_visible (in that case, XOFF and YOFF are the current
12764 position values). It is -1 when calling from x_set_frame_parameters,
12765 which means, do adjust for borders but don't change the gravity. */
12768 x_set_offset (f
, xoff
, yoff
, change_gravity
)
12770 register int xoff
, yoff
;
12771 int change_gravity
;
12773 int modified_top
, modified_left
;
12775 if (change_gravity
> 0)
12777 f
->output_data
.x
->top_pos
= yoff
;
12778 f
->output_data
.x
->left_pos
= xoff
;
12779 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
12781 f
->output_data
.x
->size_hint_flags
|= XNegative
;
12783 f
->output_data
.x
->size_hint_flags
|= YNegative
;
12784 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
12786 x_calc_absolute_position (f
);
12789 x_wm_set_size_hint (f
, (long) 0, 0);
12791 modified_left
= f
->output_data
.x
->left_pos
;
12792 modified_top
= f
->output_data
.x
->top_pos
;
12793 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
12794 this seems to be unnecessary and incorrect. rms, 4/17/97. */
12795 /* It is a mystery why we need to add the border_width here
12796 when the frame is already visible, but experiment says we do. */
12797 if (change_gravity
!= 0)
12799 modified_left
+= f
->output_data
.x
->border_width
;
12800 modified_top
+= f
->output_data
.x
->border_width
;
12804 #ifdef USE_X_TOOLKIT
12805 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
12806 modified_left
, modified_top
);
12807 #else /* not USE_X_TOOLKIT */
12808 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
12809 modified_left
, modified_top
);
12810 #endif /* not USE_X_TOOLKIT */
12814 /* Check if we need to resize the frame due to a fullscreen request.
12815 If so needed, resize the frame. */
12817 x_check_fullscreen (f
)
12820 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_BOTH
)
12822 int width
, height
, ign
;
12824 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
12825 &f
->output_data
.x
->top_pos
);
12827 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
12829 /* We do not need to move the window, it shall be taken care of
12830 when setting WM manager hints.
12831 If the frame is visible already, the position is checked by
12832 x_check_fullscreen_move. */
12833 if (f
->width
!= width
|| f
->height
!= height
)
12835 change_frame_size (f
, height
, width
, 0, 1, 0);
12836 SET_FRAME_GARBAGED (f
);
12837 cancel_mouse_face (f
);
12839 /* Wait for the change of frame size to occur */
12840 f
->output_data
.x
->want_fullscreen
|= FULLSCREEN_WAIT
;
12846 /* If frame parameters are set after the frame is mapped, we need to move
12847 the window. This is done in xfns.c.
12848 Some window managers moves the window to the right position, some
12849 moves the outer window manager window to the specified position.
12850 Here we check that we are in the right spot. If not, make a second
12851 move, assuming we are dealing with the second kind of window manager. */
12853 x_check_fullscreen_move (f
)
12856 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_MOVE_WAIT
)
12858 int expect_top
= f
->output_data
.x
->top_pos
;
12859 int expect_left
= f
->output_data
.x
->left_pos
;
12861 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_HEIGHT
)
12863 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_WIDTH
)
12866 if (expect_top
!= f
->output_data
.x
->top_pos
12867 || expect_left
!= f
->output_data
.x
->left_pos
)
12868 x_set_offset (f
, expect_left
, expect_top
, 1);
12870 /* Just do this once */
12871 f
->output_data
.x
->want_fullscreen
&= ~FULLSCREEN_MOVE_WAIT
;
12876 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
12877 wanted positions of the WM window (not emacs window).
12878 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
12879 window (FRAME_X_WINDOW).
12882 x_fullscreen_adjust (f
, width
, height
, top_pos
, left_pos
)
12889 int newwidth
= f
->width
, newheight
= f
->height
;
12891 *top_pos
= f
->output_data
.x
->top_pos
;
12892 *left_pos
= f
->output_data
.x
->left_pos
;
12894 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_HEIGHT
)
12898 ph
= FRAME_X_DISPLAY_INFO (f
)->height
;
12899 newheight
= PIXEL_TO_CHAR_HEIGHT (f
, ph
);
12900 ph
= CHAR_TO_PIXEL_HEIGHT (f
, newheight
)
12901 - f
->output_data
.x
->y_pixels_diff
;
12902 newheight
= PIXEL_TO_CHAR_HEIGHT (f
, ph
);
12906 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_WIDTH
)
12910 pw
= FRAME_X_DISPLAY_INFO (f
)->width
;
12911 newwidth
= PIXEL_TO_CHAR_WIDTH (f
, pw
);
12912 pw
= CHAR_TO_PIXEL_WIDTH (f
, newwidth
)
12913 - f
->output_data
.x
->x_pixels_diff
;
12914 newwidth
= PIXEL_TO_CHAR_WIDTH (f
, pw
);
12919 *height
= newheight
;
12923 /* Change the size of frame F's X window to COLS/ROWS in the case F
12924 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
12925 top-left-corner window gravity for this size change and subsequent
12926 size changes. Otherwise we leave the window gravity unchanged. */
12929 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
12931 int change_gravity
;
12934 int pixelwidth
, pixelheight
;
12936 check_frame_size (f
, &rows
, &cols
);
12937 f
->output_data
.x
->vertical_scroll_bar_extra
12938 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
12940 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
12941 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
12942 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
12944 x_compute_fringe_widths (f
, 0);
12946 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
12947 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
12949 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
12950 x_wm_set_size_hint (f
, (long) 0, 0);
12952 XSync (FRAME_X_DISPLAY (f
), False
);
12953 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
12954 pixelwidth
, pixelheight
);
12956 /* Now, strictly speaking, we can't be sure that this is accurate,
12957 but the window manager will get around to dealing with the size
12958 change request eventually, and we'll hear how it went when the
12959 ConfigureNotify event gets here.
12961 We could just not bother storing any of this information here,
12962 and let the ConfigureNotify event set everything up, but that
12963 might be kind of confusing to the Lisp code, since size changes
12964 wouldn't be reported in the frame parameters until some random
12965 point in the future when the ConfigureNotify event arrives.
12967 We pass 1 for DELAY since we can't run Lisp code inside of
12969 change_frame_size (f
, rows
, cols
, 0, 1, 0);
12970 PIXEL_WIDTH (f
) = pixelwidth
;
12971 PIXEL_HEIGHT (f
) = pixelheight
;
12973 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
12974 receive in the ConfigureNotify event; if we get what we asked
12975 for, then the event won't cause the screen to become garbaged, so
12976 we have to make sure to do it here. */
12977 SET_FRAME_GARBAGED (f
);
12979 XFlush (FRAME_X_DISPLAY (f
));
12983 /* Call this to change the size of frame F's x-window.
12984 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
12985 for this size change and subsequent size changes.
12986 Otherwise we leave the window gravity unchanged. */
12989 x_set_window_size (f
, change_gravity
, cols
, rows
)
12991 int change_gravity
;
12996 #ifdef USE_X_TOOLKIT
12998 if (f
->output_data
.x
->widget
!= NULL
)
13000 /* The x and y position of the widget is clobbered by the
13001 call to XtSetValues within EmacsFrameSetCharSize.
13002 This is a real kludge, but I don't understand Xt so I can't
13003 figure out a correct fix. Can anyone else tell me? -- rms. */
13004 int xpos
= f
->output_data
.x
->widget
->core
.x
;
13005 int ypos
= f
->output_data
.x
->widget
->core
.y
;
13006 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
13007 f
->output_data
.x
->widget
->core
.x
= xpos
;
13008 f
->output_data
.x
->widget
->core
.y
= ypos
;
13011 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
13013 #else /* not USE_X_TOOLKIT */
13015 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
13017 #endif /* not USE_X_TOOLKIT */
13019 /* If cursor was outside the new size, mark it as off. */
13020 mark_window_cursors_off (XWINDOW (f
->root_window
));
13022 /* Clear out any recollection of where the mouse highlighting was,
13023 since it might be in a place that's outside the new frame size.
13024 Actually checking whether it is outside is a pain in the neck,
13025 so don't try--just let the highlighting be done afresh with new size. */
13026 cancel_mouse_face (f
);
13031 /* Mouse warping. */
13034 x_set_mouse_position (f
, x
, y
)
13040 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
13041 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
13043 if (pix_x
< 0) pix_x
= 0;
13044 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
13046 if (pix_y
< 0) pix_y
= 0;
13047 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
13051 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
13052 0, 0, 0, 0, pix_x
, pix_y
);
13056 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
13059 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
13065 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
13066 0, 0, 0, 0, pix_x
, pix_y
);
13070 /* focus shifting, raising and lowering. */
13073 x_focus_on_frame (f
)
13076 #if 0 /* This proves to be unpleasant. */
13080 /* I don't think that the ICCCM allows programs to do things like this
13081 without the interaction of the window manager. Whatever you end up
13082 doing with this code, do it to x_unfocus_frame too. */
13083 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
13084 RevertToPointerRoot
, CurrentTime
);
13089 x_unfocus_frame (f
)
13093 /* Look at the remarks in x_focus_on_frame. */
13094 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
13095 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
13096 RevertToPointerRoot
, CurrentTime
);
13100 /* Raise frame F. */
13106 if (f
->async_visible
)
13109 #ifdef USE_X_TOOLKIT
13110 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
13111 #else /* not USE_X_TOOLKIT */
13112 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13113 #endif /* not USE_X_TOOLKIT */
13114 XFlush (FRAME_X_DISPLAY (f
));
13119 /* Lower frame F. */
13125 if (f
->async_visible
)
13128 #ifdef USE_X_TOOLKIT
13129 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
13130 #else /* not USE_X_TOOLKIT */
13131 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13132 #endif /* not USE_X_TOOLKIT */
13133 XFlush (FRAME_X_DISPLAY (f
));
13139 XTframe_raise_lower (f
, raise_flag
)
13149 /* Change of visibility. */
13151 /* This tries to wait until the frame is really visible.
13152 However, if the window manager asks the user where to position
13153 the frame, this will return before the user finishes doing that.
13154 The frame will not actually be visible at that time,
13155 but it will become visible later when the window manager
13156 finishes with it. */
13159 x_make_frame_visible (f
)
13163 int original_top
, original_left
;
13164 int retry_count
= 2;
13170 type
= x_icon_type (f
);
13172 x_bitmap_icon (f
, type
);
13174 if (! FRAME_VISIBLE_P (f
))
13176 /* We test FRAME_GARBAGED_P here to make sure we don't
13177 call x_set_offset a second time
13178 if we get to x_make_frame_visible a second time
13179 before the window gets really visible. */
13180 if (! FRAME_ICONIFIED_P (f
)
13181 && ! f
->output_data
.x
->asked_for_visible
)
13182 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
13184 f
->output_data
.x
->asked_for_visible
= 1;
13186 if (! EQ (Vx_no_window_manager
, Qt
))
13187 x_wm_set_window_state (f
, NormalState
);
13188 #ifdef USE_X_TOOLKIT
13189 /* This was XtPopup, but that did nothing for an iconified frame. */
13190 XtMapWidget (f
->output_data
.x
->widget
);
13191 #else /* not USE_X_TOOLKIT */
13192 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13193 #endif /* not USE_X_TOOLKIT */
13194 #if 0 /* This seems to bring back scroll bars in the wrong places
13195 if the window configuration has changed. They seem
13196 to come back ok without this. */
13197 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
13198 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13202 XFlush (FRAME_X_DISPLAY (f
));
13204 /* Synchronize to ensure Emacs knows the frame is visible
13205 before we do anything else. We do this loop with input not blocked
13206 so that incoming events are handled. */
13210 /* This must be before UNBLOCK_INPUT
13211 since events that arrive in response to the actions above
13212 will set it when they are handled. */
13213 int previously_visible
= f
->output_data
.x
->has_been_visible
;
13215 original_left
= f
->output_data
.x
->left_pos
;
13216 original_top
= f
->output_data
.x
->top_pos
;
13218 /* This must come after we set COUNT. */
13221 /* We unblock here so that arriving X events are processed. */
13223 /* Now move the window back to where it was "supposed to be".
13224 But don't do it if the gravity is negative.
13225 When the gravity is negative, this uses a position
13226 that is 3 pixels too low. Perhaps that's really the border width.
13228 Don't do this if the window has never been visible before,
13229 because the window manager may choose the position
13230 and we don't want to override it. */
13232 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
13233 && f
->output_data
.x
->win_gravity
== NorthWestGravity
13234 && previously_visible
)
13238 unsigned int width
, height
, border
, depth
;
13242 /* On some window managers (such as FVWM) moving an existing
13243 window, even to the same place, causes the window manager
13244 to introduce an offset. This can cause the window to move
13245 to an unexpected location. Check the geometry (a little
13246 slow here) and then verify that the window is in the right
13247 place. If the window is not in the right place, move it
13248 there, and take the potential window manager hit. */
13249 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
13250 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
13252 if (original_left
!= x
|| original_top
!= y
)
13253 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
13254 original_left
, original_top
);
13259 XSETFRAME (frame
, f
);
13261 /* Wait until the frame is visible. Process X events until a
13262 MapNotify event has been seen, or until we think we won't get a
13263 MapNotify at all.. */
13264 for (count
= input_signal_count
+ 10;
13265 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
13267 /* Force processing of queued events. */
13270 /* Machines that do polling rather than SIGIO have been
13271 observed to go into a busy-wait here. So we'll fake an
13272 alarm signal to let the handler know that there's something
13273 to be read. We used to raise a real alarm, but it seems
13274 that the handler isn't always enabled here. This is
13276 if (input_polling_used ())
13278 /* It could be confusing if a real alarm arrives while
13279 processing the fake one. Turn it off and let the
13280 handler reset it. */
13281 extern void poll_for_input_1
P_ ((void));
13282 int old_poll_suppress_count
= poll_suppress_count
;
13283 poll_suppress_count
= 1;
13284 poll_for_input_1 ();
13285 poll_suppress_count
= old_poll_suppress_count
;
13288 /* See if a MapNotify event has been processed. */
13289 FRAME_SAMPLE_VISIBILITY (f
);
13294 (let ((f (selected-frame)))
13298 the frame is not raised with various window managers on
13299 FreeBSD, Linux and Solaris. It turns out that, for some
13300 unknown reason, the call to XtMapWidget is completely ignored.
13301 Mapping the widget a second time works. */
13303 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
13308 /* Change from mapped state to withdrawn state. */
13310 /* Make the frame visible (mapped and not iconified). */
13313 x_make_frame_invisible (f
)
13318 #ifdef USE_X_TOOLKIT
13319 /* Use the frame's outermost window, not the one we normally draw on. */
13320 window
= XtWindow (f
->output_data
.x
->widget
);
13321 #else /* not USE_X_TOOLKIT */
13322 window
= FRAME_X_WINDOW (f
);
13323 #endif /* not USE_X_TOOLKIT */
13325 /* Don't keep the highlight on an invisible frame. */
13326 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
13327 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
13329 #if 0/* This might add unreliability; I don't trust it -- rms. */
13330 if (! f
->async_visible
&& ! f
->async_iconified
)
13336 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
13337 that the current position of the window is user-specified, rather than
13338 program-specified, so that when the window is mapped again, it will be
13339 placed at the same location, without forcing the user to position it
13340 by hand again (they have already done that once for this window.) */
13341 x_wm_set_size_hint (f
, (long) 0, 1);
13345 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
13346 DefaultScreen (FRAME_X_DISPLAY (f
))))
13348 UNBLOCK_INPUT_RESIGNAL
;
13349 error ("Can't notify window manager of window withdrawal");
13351 #else /* ! defined (HAVE_X11R4) */
13353 /* Tell the window manager what we're going to do. */
13354 if (! EQ (Vx_no_window_manager
, Qt
))
13358 unmap
.xunmap
.type
= UnmapNotify
;
13359 unmap
.xunmap
.window
= window
;
13360 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
13361 unmap
.xunmap
.from_configure
= False
;
13362 if (! XSendEvent (FRAME_X_DISPLAY (f
),
13363 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
13365 SubstructureRedirectMaskSubstructureNotifyMask
,
13368 UNBLOCK_INPUT_RESIGNAL
;
13369 error ("Can't notify window manager of withdrawal");
13373 /* Unmap the window ourselves. Cheeky! */
13374 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
13375 #endif /* ! defined (HAVE_X11R4) */
13377 /* We can't distinguish this from iconification
13378 just by the event that we get from the server.
13379 So we can't win using the usual strategy of letting
13380 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
13381 and synchronize with the server to make sure we agree. */
13383 FRAME_ICONIFIED_P (f
) = 0;
13384 f
->async_visible
= 0;
13385 f
->async_iconified
= 0;
13392 /* Change window state from mapped to iconified. */
13395 x_iconify_frame (f
)
13401 /* Don't keep the highlight on an invisible frame. */
13402 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
13403 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
13405 if (f
->async_iconified
)
13410 FRAME_SAMPLE_VISIBILITY (f
);
13412 type
= x_icon_type (f
);
13414 x_bitmap_icon (f
, type
);
13416 #ifdef USE_X_TOOLKIT
13418 if (! FRAME_VISIBLE_P (f
))
13420 if (! EQ (Vx_no_window_manager
, Qt
))
13421 x_wm_set_window_state (f
, IconicState
);
13422 /* This was XtPopup, but that did nothing for an iconified frame. */
13423 XtMapWidget (f
->output_data
.x
->widget
);
13424 /* The server won't give us any event to indicate
13425 that an invisible frame was changed to an icon,
13426 so we have to record it here. */
13429 f
->async_iconified
= 1;
13430 f
->async_visible
= 0;
13435 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
13436 XtWindow (f
->output_data
.x
->widget
),
13437 DefaultScreen (FRAME_X_DISPLAY (f
)));
13441 error ("Can't notify window manager of iconification");
13443 f
->async_iconified
= 1;
13444 f
->async_visible
= 0;
13448 XFlush (FRAME_X_DISPLAY (f
));
13450 #else /* not USE_X_TOOLKIT */
13452 /* Make sure the X server knows where the window should be positioned,
13453 in case the user deiconifies with the window manager. */
13454 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
13455 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
13457 /* Since we don't know which revision of X we're running, we'll use both
13458 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
13460 /* X11R4: send a ClientMessage to the window manager using the
13461 WM_CHANGE_STATE type. */
13465 message
.xclient
.window
= FRAME_X_WINDOW (f
);
13466 message
.xclient
.type
= ClientMessage
;
13467 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
13468 message
.xclient
.format
= 32;
13469 message
.xclient
.data
.l
[0] = IconicState
;
13471 if (! XSendEvent (FRAME_X_DISPLAY (f
),
13472 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
13474 SubstructureRedirectMask
| SubstructureNotifyMask
,
13477 UNBLOCK_INPUT_RESIGNAL
;
13478 error ("Can't notify window manager of iconification");
13482 /* X11R3: set the initial_state field of the window manager hints to
13484 x_wm_set_window_state (f
, IconicState
);
13486 if (!FRAME_VISIBLE_P (f
))
13488 /* If the frame was withdrawn, before, we must map it. */
13489 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13492 f
->async_iconified
= 1;
13493 f
->async_visible
= 0;
13495 XFlush (FRAME_X_DISPLAY (f
));
13497 #endif /* not USE_X_TOOLKIT */
13501 /* Free X resources of frame F. */
13504 x_free_frame_resources (f
)
13507 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13509 struct scroll_bar
*b
;
13513 /* If a display connection is dead, don't try sending more
13514 commands to the X server. */
13515 if (dpyinfo
->display
)
13517 if (f
->output_data
.x
->icon_desc
)
13518 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
13520 #ifdef USE_X_TOOLKIT
13521 /* Explicitly destroy the scroll bars of the frame. Without
13522 this, we get "BadDrawable" errors from the toolkit later on,
13523 presumably from expose events generated for the disappearing
13524 toolkit scroll bars. */
13525 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
13527 b
= XSCROLL_BAR (bar
);
13528 x_scroll_bar_remove (b
);
13534 free_frame_xic (f
);
13537 #ifdef USE_X_TOOLKIT
13538 if (f
->output_data
.x
->widget
)
13540 XtDestroyWidget (f
->output_data
.x
->widget
);
13541 f
->output_data
.x
->widget
= NULL
;
13543 /* Tooltips don't have widgets, only a simple X window, even if
13544 we are using a toolkit. */
13545 else if (FRAME_X_WINDOW (f
))
13546 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13548 free_frame_menubar (f
);
13549 #else /* !USE_X_TOOLKIT */
13550 if (FRAME_X_WINDOW (f
))
13551 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13552 #endif /* !USE_X_TOOLKIT */
13554 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
13555 unload_color (f
, f
->output_data
.x
->background_pixel
);
13556 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
13557 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
13558 unload_color (f
, f
->output_data
.x
->border_pixel
);
13559 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
13561 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
13562 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
13563 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
13564 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
13565 #ifdef USE_TOOLKIT_SCROLL_BARS
13566 /* Scrollbar shadow colors. */
13567 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
13568 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
13569 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
13570 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
13571 #endif /* USE_TOOLKIT_SCROLL_BARS */
13572 if (f
->output_data
.x
->white_relief
.allocated_p
)
13573 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
13574 if (f
->output_data
.x
->black_relief
.allocated_p
)
13575 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
13577 if (FRAME_FACE_CACHE (f
))
13578 free_frame_faces (f
);
13581 XFlush (FRAME_X_DISPLAY (f
));
13584 if (f
->output_data
.x
->saved_menu_event
)
13585 xfree (f
->output_data
.x
->saved_menu_event
);
13587 xfree (f
->output_data
.x
);
13588 f
->output_data
.x
= NULL
;
13590 if (f
== dpyinfo
->x_focus_frame
)
13591 dpyinfo
->x_focus_frame
= 0;
13592 if (f
== dpyinfo
->x_focus_event_frame
)
13593 dpyinfo
->x_focus_event_frame
= 0;
13594 if (f
== dpyinfo
->x_highlight_frame
)
13595 dpyinfo
->x_highlight_frame
= 0;
13597 if (f
== dpyinfo
->mouse_face_mouse_frame
)
13599 dpyinfo
->mouse_face_beg_row
13600 = dpyinfo
->mouse_face_beg_col
= -1;
13601 dpyinfo
->mouse_face_end_row
13602 = dpyinfo
->mouse_face_end_col
= -1;
13603 dpyinfo
->mouse_face_window
= Qnil
;
13604 dpyinfo
->mouse_face_deferred_gc
= 0;
13605 dpyinfo
->mouse_face_mouse_frame
= 0;
13612 /* Destroy the X window of frame F. */
13615 x_destroy_window (f
)
13618 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13620 /* If a display connection is dead, don't try sending more
13621 commands to the X server. */
13622 if (dpyinfo
->display
!= 0)
13623 x_free_frame_resources (f
);
13625 dpyinfo
->reference_count
--;
13629 /* Setting window manager hints. */
13631 /* Set the normal size hints for the window manager, for frame F.
13632 FLAGS is the flags word to use--or 0 meaning preserve the flags
13633 that the window now has.
13634 If USER_POSITION is nonzero, we set the USPosition
13635 flag (this is useful when FLAGS is 0). */
13638 x_wm_set_size_hint (f
, flags
, user_position
)
13643 XSizeHints size_hints
;
13645 #ifdef USE_X_TOOLKIT
13648 Dimension widget_width
, widget_height
;
13649 Window window
= XtWindow (f
->output_data
.x
->widget
);
13650 #else /* not USE_X_TOOLKIT */
13651 Window window
= FRAME_X_WINDOW (f
);
13652 #endif /* not USE_X_TOOLKIT */
13654 /* Setting PMaxSize caused various problems. */
13655 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
13657 size_hints
.x
= f
->output_data
.x
->left_pos
;
13658 size_hints
.y
= f
->output_data
.x
->top_pos
;
13660 #ifdef USE_X_TOOLKIT
13661 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
13662 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
13663 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
13664 size_hints
.height
= widget_height
;
13665 size_hints
.width
= widget_width
;
13666 #else /* not USE_X_TOOLKIT */
13667 size_hints
.height
= PIXEL_HEIGHT (f
);
13668 size_hints
.width
= PIXEL_WIDTH (f
);
13669 #endif /* not USE_X_TOOLKIT */
13671 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
13672 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
13673 size_hints
.max_width
13674 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
13675 size_hints
.max_height
13676 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
13678 /* Calculate the base and minimum sizes.
13680 (When we use the X toolkit, we don't do it here.
13681 Instead we copy the values that the widgets are using, below.) */
13682 #ifndef USE_X_TOOLKIT
13684 int base_width
, base_height
;
13685 int min_rows
= 0, min_cols
= 0;
13687 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
13688 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
13690 check_frame_size (f
, &min_rows
, &min_cols
);
13692 /* The window manager uses the base width hints to calculate the
13693 current number of rows and columns in the frame while
13694 resizing; min_width and min_height aren't useful for this
13695 purpose, since they might not give the dimensions for a
13696 zero-row, zero-column frame.
13698 We use the base_width and base_height members if we have
13699 them; otherwise, we set the min_width and min_height members
13700 to the size for a zero x zero frame. */
13703 size_hints
.flags
|= PBaseSize
;
13704 size_hints
.base_width
= base_width
;
13705 size_hints
.base_height
= base_height
;
13706 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
13707 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
13709 size_hints
.min_width
= base_width
;
13710 size_hints
.min_height
= base_height
;
13714 /* If we don't need the old flags, we don't need the old hint at all. */
13717 size_hints
.flags
|= flags
;
13720 #endif /* not USE_X_TOOLKIT */
13723 XSizeHints hints
; /* Sometimes I hate X Windows... */
13724 long supplied_return
;
13728 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
13731 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
13734 #ifdef USE_X_TOOLKIT
13735 size_hints
.base_height
= hints
.base_height
;
13736 size_hints
.base_width
= hints
.base_width
;
13737 size_hints
.min_height
= hints
.min_height
;
13738 size_hints
.min_width
= hints
.min_width
;
13742 size_hints
.flags
|= flags
;
13747 if (hints
.flags
& PSize
)
13748 size_hints
.flags
|= PSize
;
13749 if (hints
.flags
& PPosition
)
13750 size_hints
.flags
|= PPosition
;
13751 if (hints
.flags
& USPosition
)
13752 size_hints
.flags
|= USPosition
;
13753 if (hints
.flags
& USSize
)
13754 size_hints
.flags
|= USSize
;
13758 #ifndef USE_X_TOOLKIT
13763 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
13764 size_hints
.flags
|= PWinGravity
;
13768 size_hints
.flags
&= ~ PPosition
;
13769 size_hints
.flags
|= USPosition
;
13771 #endif /* PWinGravity */
13774 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
13776 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
13780 /* Used for IconicState or NormalState */
13783 x_wm_set_window_state (f
, state
)
13787 #ifdef USE_X_TOOLKIT
13790 XtSetArg (al
[0], XtNinitialState
, state
);
13791 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
13792 #else /* not USE_X_TOOLKIT */
13793 Window window
= FRAME_X_WINDOW (f
);
13795 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
13796 f
->output_data
.x
->wm_hints
.initial_state
= state
;
13798 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
13799 #endif /* not USE_X_TOOLKIT */
13803 x_wm_set_icon_pixmap (f
, pixmap_id
)
13807 Pixmap icon_pixmap
;
13809 #ifndef USE_X_TOOLKIT
13810 Window window
= FRAME_X_WINDOW (f
);
13815 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
13816 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
13820 /* It seems there is no way to turn off use of an icon pixmap.
13821 The following line does it, only if no icon has yet been created,
13822 for some window managers. But with mwm it crashes.
13823 Some people say it should clear the IconPixmapHint bit in this case,
13824 but that doesn't work, and the X consortium said it isn't the
13825 right thing at all. Since there is no way to win,
13826 best to explicitly give up. */
13828 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
13834 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
13838 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
13839 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
13842 #else /* not USE_X_TOOLKIT */
13844 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
13845 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
13847 #endif /* not USE_X_TOOLKIT */
13851 x_wm_set_icon_position (f
, icon_x
, icon_y
)
13853 int icon_x
, icon_y
;
13855 #ifdef USE_X_TOOLKIT
13856 Window window
= XtWindow (f
->output_data
.x
->widget
);
13858 Window window
= FRAME_X_WINDOW (f
);
13861 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
13862 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
13863 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
13865 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
13869 /***********************************************************************
13871 ***********************************************************************/
13873 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
13876 x_get_font_info (f
, font_idx
)
13880 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
13884 /* Return a list of names of available fonts matching PATTERN on frame F.
13886 If SIZE is > 0, it is the size (maximum bounds width) of fonts
13889 SIZE < 0 means include scalable fonts.
13891 Frame F null means we have not yet created any frame on X, and
13892 consult the first display in x_display_list. MAXNAMES sets a limit
13893 on how many fonts to match. */
13896 x_list_fonts (f
, pattern
, size
, maxnames
)
13898 Lisp_Object pattern
;
13902 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
13903 Lisp_Object tem
, second_best
;
13904 struct x_display_info
*dpyinfo
13905 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
13906 Display
*dpy
= dpyinfo
->display
;
13907 int try_XLoadQueryFont
= 0;
13909 int allow_scalable_fonts_p
= 0;
13913 allow_scalable_fonts_p
= 1;
13917 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
13918 if (NILP (patterns
))
13919 patterns
= Fcons (pattern
, Qnil
);
13921 if (maxnames
== 1 && !size
)
13922 /* We can return any single font matching PATTERN. */
13923 try_XLoadQueryFont
= 1;
13925 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
13928 char **names
= NULL
;
13930 pattern
= XCAR (patterns
);
13931 /* See if we cached the result for this particular query.
13932 The cache is an alist of the form:
13933 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
13934 tem
= XCDR (dpyinfo
->name_list_element
);
13935 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
13936 allow_scalable_fonts_p
? Qt
: Qnil
);
13937 list
= Fassoc (key
, tem
);
13940 list
= Fcdr_safe (list
);
13941 /* We have a cashed list. Don't have to get the list again. */
13945 /* At first, put PATTERN in the cache. */
13948 count
= x_catch_errors (dpy
);
13950 if (try_XLoadQueryFont
)
13953 unsigned long value
;
13955 font
= XLoadQueryFont (dpy
, XSTRING (pattern
)->data
);
13956 if (x_had_errors_p (dpy
))
13958 /* This error is perhaps due to insufficient memory on X
13959 server. Let's just ignore it. */
13961 x_clear_errors (dpy
);
13965 && XGetFontProperty (font
, XA_FONT
, &value
))
13967 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
13968 int len
= strlen (name
);
13971 /* If DXPC (a Differential X Protocol Compressor)
13972 Ver.3.7 is running, XGetAtomName will return null
13973 string. We must avoid such a name. */
13975 try_XLoadQueryFont
= 0;
13979 names
= (char **) alloca (sizeof (char *));
13980 /* Some systems only allow alloca assigned to a
13982 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
13983 bcopy (name
, names
[0], len
+ 1);
13988 try_XLoadQueryFont
= 0;
13991 XFreeFont (dpy
, font
);
13994 if (!try_XLoadQueryFont
)
13996 /* We try at least 10 fonts because XListFonts will return
13997 auto-scaled fonts at the head. */
13998 names
= XListFonts (dpy
, XSTRING (pattern
)->data
, max (maxnames
, 10),
14000 if (x_had_errors_p (dpy
))
14002 /* This error is perhaps due to insufficient memory on X
14003 server. Let's just ignore it. */
14005 x_clear_errors (dpy
);
14009 x_uncatch_errors (dpy
, count
);
14016 /* Make a list of all the fonts we got back.
14017 Store that in the font cache for the display. */
14018 for (i
= 0; i
< num_fonts
; i
++)
14021 char *p
= names
[i
];
14022 int average_width
= -1, dashes
= 0;
14024 /* Count the number of dashes in NAMES[I]. If there are
14025 14 dashes, and the field value following 12th dash
14026 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
14027 is usually too ugly to be used for editing. Let's
14033 if (dashes
== 7) /* PIXEL_SIZE field */
14035 else if (dashes
== 12) /* AVERAGE_WIDTH field */
14036 average_width
= atoi (p
);
14039 if (allow_scalable_fonts_p
14040 || dashes
< 14 || average_width
!= 0)
14042 tem
= build_string (names
[i
]);
14043 if (NILP (Fassoc (tem
, list
)))
14045 if (STRINGP (Vx_pixel_size_width_font_regexp
)
14046 && ((fast_c_string_match_ignore_case
14047 (Vx_pixel_size_width_font_regexp
, names
[i
]))
14049 /* We can set the value of PIXEL_SIZE to the
14050 width of this font. */
14051 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
14053 /* For the moment, width is not known. */
14054 list
= Fcons (Fcons (tem
, Qnil
), list
);
14059 if (!try_XLoadQueryFont
)
14062 XFreeFontNames (names
);
14067 /* Now store the result in the cache. */
14068 XSETCDR (dpyinfo
->name_list_element
,
14069 Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
)));
14072 if (NILP (list
)) continue; /* Try the remaining alternatives. */
14074 newlist
= second_best
= Qnil
;
14075 /* Make a list of the fonts that have the right width. */
14076 for (; CONSP (list
); list
= XCDR (list
))
14082 if (!CONSP (tem
) || NILP (XCAR (tem
)))
14086 newlist
= Fcons (XCAR (tem
), newlist
);
14090 if (!INTEGERP (XCDR (tem
)))
14092 /* Since we have not yet known the size of this font, we
14093 must try slow function call XLoadQueryFont. */
14094 XFontStruct
*thisinfo
;
14097 count
= x_catch_errors (dpy
);
14098 thisinfo
= XLoadQueryFont (dpy
,
14099 XSTRING (XCAR (tem
))->data
);
14100 if (x_had_errors_p (dpy
))
14102 /* This error is perhaps due to insufficient memory on X
14103 server. Let's just ignore it. */
14105 x_clear_errors (dpy
);
14107 x_uncatch_errors (dpy
, count
);
14113 (thisinfo
->min_bounds
.width
== 0
14115 : make_number (thisinfo
->max_bounds
.width
)));
14117 XFreeFont (dpy
, thisinfo
);
14121 /* For unknown reason, the previous call of XListFont had
14122 returned a font which can't be opened. Record the size
14123 as 0 not to try to open it again. */
14124 XSETCDR (tem
, make_number (0));
14127 found_size
= XINT (XCDR (tem
));
14128 if (found_size
== size
)
14129 newlist
= Fcons (XCAR (tem
), newlist
);
14130 else if (found_size
> 0)
14132 if (NILP (second_best
))
14134 else if (found_size
< size
)
14136 if (XINT (XCDR (second_best
)) > size
14137 || XINT (XCDR (second_best
)) < found_size
)
14142 if (XINT (XCDR (second_best
)) > size
14143 && XINT (XCDR (second_best
)) > found_size
)
14148 if (!NILP (newlist
))
14150 else if (!NILP (second_best
))
14152 newlist
= Fcons (XCAR (second_best
), Qnil
);
14163 /* Check that FONT is valid on frame F. It is if it can be found in F's
14167 x_check_font (f
, font
)
14172 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
14174 xassert (font
!= NULL
);
14176 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
14177 if (dpyinfo
->font_table
[i
].name
14178 && font
== dpyinfo
->font_table
[i
].font
)
14181 xassert (i
< dpyinfo
->n_fonts
);
14184 #endif /* GLYPH_DEBUG != 0 */
14186 /* Set *W to the minimum width, *H to the minimum font height of FONT.
14187 Note: There are (broken) X fonts out there with invalid XFontStruct
14188 min_bounds contents. For example, handa@etl.go.jp reports that
14189 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
14190 have font->min_bounds.width == 0. */
14193 x_font_min_bounds (font
, w
, h
)
14197 *h
= FONT_HEIGHT (font
);
14198 *w
= font
->min_bounds
.width
;
14200 /* Try to handle the case where FONT->min_bounds has invalid
14201 contents. Since the only font known to have invalid min_bounds
14202 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
14204 *w
= font
->max_bounds
.width
;
14208 /* Compute the smallest character width and smallest font height over
14209 all fonts available on frame F. Set the members smallest_char_width
14210 and smallest_font_height in F's x_display_info structure to
14211 the values computed. Value is non-zero if smallest_font_height or
14212 smallest_char_width become smaller than they were before. */
14215 x_compute_min_glyph_bounds (f
)
14219 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
14221 int old_width
= dpyinfo
->smallest_char_width
;
14222 int old_height
= dpyinfo
->smallest_font_height
;
14224 dpyinfo
->smallest_font_height
= 100000;
14225 dpyinfo
->smallest_char_width
= 100000;
14227 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
14228 if (dpyinfo
->font_table
[i
].name
)
14230 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
14233 font
= (XFontStruct
*) fontp
->font
;
14234 xassert (font
!= (XFontStruct
*) ~0);
14235 x_font_min_bounds (font
, &w
, &h
);
14237 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
14238 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
14241 xassert (dpyinfo
->smallest_char_width
> 0
14242 && dpyinfo
->smallest_font_height
> 0);
14244 return (dpyinfo
->n_fonts
== 1
14245 || dpyinfo
->smallest_char_width
< old_width
14246 || dpyinfo
->smallest_font_height
< old_height
);
14250 /* Load font named FONTNAME of the size SIZE for frame F, and return a
14251 pointer to the structure font_info while allocating it dynamically.
14252 If SIZE is 0, load any size of font.
14253 If loading is failed, return NULL. */
14256 x_load_font (f
, fontname
, size
)
14258 register char *fontname
;
14261 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
14262 Lisp_Object font_names
;
14265 /* Get a list of all the fonts that match this name. Once we
14266 have a list of matching fonts, we compare them against the fonts
14267 we already have by comparing names. */
14268 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
14270 if (!NILP (font_names
))
14275 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
14276 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
14277 if (dpyinfo
->font_table
[i
].name
14278 && (!strcmp (dpyinfo
->font_table
[i
].name
,
14279 XSTRING (XCAR (tail
))->data
)
14280 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
14281 XSTRING (XCAR (tail
))->data
)))
14282 return (dpyinfo
->font_table
+ i
);
14285 /* Load the font and add it to the table. */
14289 struct font_info
*fontp
;
14290 unsigned long value
;
14293 /* If we have found fonts by x_list_font, load one of them. If
14294 not, we still try to load a font by the name given as FONTNAME
14295 because XListFonts (called in x_list_font) of some X server has
14296 a bug of not finding a font even if the font surely exists and
14297 is loadable by XLoadQueryFont. */
14298 if (size
> 0 && !NILP (font_names
))
14299 fontname
= (char *) XSTRING (XCAR (font_names
))->data
;
14302 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
14303 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
14304 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
14306 /* This error is perhaps due to insufficient memory on X
14307 server. Let's just ignore it. */
14309 x_clear_errors (FRAME_X_DISPLAY (f
));
14311 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
14316 /* Find a free slot in the font table. */
14317 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
14318 if (dpyinfo
->font_table
[i
].name
== NULL
)
14321 /* If no free slot found, maybe enlarge the font table. */
14322 if (i
== dpyinfo
->n_fonts
14323 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
14326 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
14327 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
14328 dpyinfo
->font_table
14329 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
14332 fontp
= dpyinfo
->font_table
+ i
;
14333 if (i
== dpyinfo
->n_fonts
)
14334 ++dpyinfo
->n_fonts
;
14336 /* Now fill in the slots of *FONTP. */
14338 fontp
->font
= font
;
14339 fontp
->font_idx
= i
;
14340 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
14341 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
14343 /* Try to get the full name of FONT. Put it in FULL_NAME. */
14345 if (XGetFontProperty (font
, XA_FONT
, &value
))
14347 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
14351 /* Count the number of dashes in the "full name".
14352 If it is too few, this isn't really the font's full name,
14354 In X11R4, the fonts did not come with their canonical names
14365 full_name
= (char *) xmalloc (p
- name
+ 1);
14366 bcopy (name
, full_name
, p
- name
+ 1);
14372 if (full_name
!= 0)
14373 fontp
->full_name
= full_name
;
14375 fontp
->full_name
= fontp
->name
;
14377 fontp
->size
= font
->max_bounds
.width
;
14378 fontp
->height
= FONT_HEIGHT (font
);
14380 if (NILP (font_names
))
14382 /* We come here because of a bug of XListFonts mentioned at
14383 the head of this block. Let's store this information in
14384 the cache for x_list_fonts. */
14385 Lisp_Object lispy_name
= build_string (fontname
);
14386 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
14387 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
14390 XSETCDR (dpyinfo
->name_list_element
,
14392 Fcons (Fcons (lispy_full_name
,
14393 make_number (fontp
->size
)),
14395 XCDR (dpyinfo
->name_list_element
)));
14398 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
14400 XSETCDR (dpyinfo
->name_list_element
,
14402 Fcons (Fcons (lispy_full_name
,
14403 make_number (fontp
->size
)),
14405 XCDR (dpyinfo
->name_list_element
)));
14409 /* The slot `encoding' specifies how to map a character
14410 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
14411 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
14412 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
14413 2:0xA020..0xFF7F). For the moment, we don't know which charset
14414 uses this font. So, we set information in fontp->encoding[1]
14415 which is never used by any charset. If mapping can't be
14416 decided, set FONT_ENCODING_NOT_DECIDED. */
14418 = (font
->max_byte1
== 0
14420 ? (font
->min_char_or_byte2
< 0x80
14421 ? (font
->max_char_or_byte2
< 0x80
14422 ? 0 /* 0x20..0x7F */
14423 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
14424 : 1) /* 0xA0..0xFF */
14426 : (font
->min_byte1
< 0x80
14427 ? (font
->max_byte1
< 0x80
14428 ? (font
->min_char_or_byte2
< 0x80
14429 ? (font
->max_char_or_byte2
< 0x80
14430 ? 0 /* 0x2020..0x7F7F */
14431 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
14432 : 3) /* 0x20A0..0x7FFF */
14433 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
14434 : (font
->min_char_or_byte2
< 0x80
14435 ? (font
->max_char_or_byte2
< 0x80
14436 ? 2 /* 0xA020..0xFF7F */
14437 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
14438 : 1))); /* 0xA0A0..0xFFFF */
14440 fontp
->baseline_offset
14441 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
14442 ? (long) value
: 0);
14443 fontp
->relative_compose
14444 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
14445 ? (long) value
: 0);
14446 fontp
->default_ascent
14447 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
14448 ? (long) value
: 0);
14450 /* Set global flag fonts_changed_p to non-zero if the font loaded
14451 has a character with a smaller width than any other character
14452 before, or if the font loaded has a smaller height than any
14453 other font loaded before. If this happens, it will make a
14454 glyph matrix reallocation necessary. */
14455 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
14462 /* Return a pointer to struct font_info of a font named FONTNAME for
14463 frame F. If no such font is loaded, return NULL. */
14466 x_query_font (f
, fontname
)
14468 register char *fontname
;
14470 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
14473 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
14474 if (dpyinfo
->font_table
[i
].name
14475 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
14476 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
14477 return (dpyinfo
->font_table
+ i
);
14482 /* Find a CCL program for a font specified by FONTP, and set the member
14483 `encoder' of the structure. */
14486 x_find_ccl_program (fontp
)
14487 struct font_info
*fontp
;
14489 Lisp_Object list
, elt
;
14492 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
14496 && STRINGP (XCAR (elt
))
14497 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
14499 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
14506 struct ccl_program
*ccl
14507 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
14509 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
14512 fontp
->font_encoder
= ccl
;
14518 /***********************************************************************
14520 ***********************************************************************/
14522 #ifdef USE_X_TOOLKIT
14523 static XrmOptionDescRec emacs_options
[] = {
14524 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
14525 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
14527 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
14528 XrmoptionSepArg
, NULL
},
14529 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
14531 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
14532 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
14533 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
14534 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
14535 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
14536 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
14537 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
14539 #endif /* USE_X_TOOLKIT */
14541 static int x_initialized
;
14543 #ifdef MULTI_KBOARD
14544 /* Test whether two display-name strings agree up to the dot that separates
14545 the screen number from the server number. */
14547 same_x_server (name1
, name2
)
14548 char *name1
, *name2
;
14550 int seen_colon
= 0;
14551 unsigned char *system_name
= XSTRING (Vsystem_name
)->data
;
14552 int system_name_length
= strlen (system_name
);
14553 int length_until_period
= 0;
14555 while (system_name
[length_until_period
] != 0
14556 && system_name
[length_until_period
] != '.')
14557 length_until_period
++;
14559 /* Treat `unix' like an empty host name. */
14560 if (! strncmp (name1
, "unix:", 5))
14562 if (! strncmp (name2
, "unix:", 5))
14564 /* Treat this host's name like an empty host name. */
14565 if (! strncmp (name1
, system_name
, system_name_length
)
14566 && name1
[system_name_length
] == ':')
14567 name1
+= system_name_length
;
14568 if (! strncmp (name2
, system_name
, system_name_length
)
14569 && name2
[system_name_length
] == ':')
14570 name2
+= system_name_length
;
14571 /* Treat this host's domainless name like an empty host name. */
14572 if (! strncmp (name1
, system_name
, length_until_period
)
14573 && name1
[length_until_period
] == ':')
14574 name1
+= length_until_period
;
14575 if (! strncmp (name2
, system_name
, length_until_period
)
14576 && name2
[length_until_period
] == ':')
14577 name2
+= length_until_period
;
14579 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
14583 if (seen_colon
&& *name1
== '.')
14587 && (*name1
== '.' || *name1
== '\0')
14588 && (*name2
== '.' || *name2
== '\0'));
14592 struct x_display_info
*
14593 x_term_init (display_name
, xrm_option
, resource_name
)
14594 Lisp_Object display_name
;
14596 char *resource_name
;
14600 struct x_display_info
*dpyinfo
;
14605 if (!x_initialized
)
14611 #ifdef USE_X_TOOLKIT
14612 /* weiner@footloose.sps.mot.com reports that this causes
14614 X protocol error: BadAtom (invalid Atom parameter)
14615 on protocol request 18skiloaf.
14616 So let's not use it until R6. */
14617 #ifdef HAVE_X11XTR6
14618 XtSetLanguageProc (NULL
, NULL
, NULL
);
14629 argv
[argc
++] = "-xrm";
14630 argv
[argc
++] = xrm_option
;
14632 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
14633 resource_name
, EMACS_CLASS
,
14634 emacs_options
, XtNumber (emacs_options
),
14637 #ifdef HAVE_X11XTR6
14638 /* I think this is to compensate for XtSetLanguageProc. */
14643 #else /* not USE_X_TOOLKIT */
14645 XSetLocaleModifiers ("");
14647 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
14648 #endif /* not USE_X_TOOLKIT */
14650 /* Detect failure. */
14657 /* We have definitely succeeded. Record the new connection. */
14659 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
14660 bzero (dpyinfo
, sizeof *dpyinfo
);
14662 #ifdef MULTI_KBOARD
14664 struct x_display_info
*share
;
14667 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
14668 share
= share
->next
, tail
= XCDR (tail
))
14669 if (same_x_server (XSTRING (XCAR (XCAR (tail
)))->data
,
14670 XSTRING (display_name
)->data
))
14673 dpyinfo
->kboard
= share
->kboard
;
14676 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
14677 init_kboard (dpyinfo
->kboard
);
14678 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
14680 char *vendor
= ServerVendor (dpy
);
14682 dpyinfo
->kboard
->Vsystem_key_alist
14683 = call1 (Qvendor_specific_keysyms
,
14684 build_string (vendor
? vendor
: ""));
14688 dpyinfo
->kboard
->next_kboard
= all_kboards
;
14689 all_kboards
= dpyinfo
->kboard
;
14690 /* Don't let the initial kboard remain current longer than necessary.
14691 That would cause problems if a file loaded on startup tries to
14692 prompt in the mini-buffer. */
14693 if (current_kboard
== initial_kboard
)
14694 current_kboard
= dpyinfo
->kboard
;
14696 dpyinfo
->kboard
->reference_count
++;
14700 /* Put this display on the chain. */
14701 dpyinfo
->next
= x_display_list
;
14702 x_display_list
= dpyinfo
;
14704 /* Put it on x_display_name_list as well, to keep them parallel. */
14705 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
14706 x_display_name_list
);
14707 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
14709 dpyinfo
->display
= dpy
;
14712 XSetAfterFunction (x_current_display
, x_trace_wire
);
14716 = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name
))
14717 + STRING_BYTES (XSTRING (Vsystem_name
))
14719 sprintf (dpyinfo
->x_id_name
, "%s@%s",
14720 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
14722 /* Figure out which modifier bits mean what. */
14723 x_find_modifier_meanings (dpyinfo
);
14725 /* Get the scroll bar cursor. */
14726 dpyinfo
->vertical_scroll_bar_cursor
14727 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
14729 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
14730 resource_name
, EMACS_CLASS
);
14731 #ifdef HAVE_XRMSETDATABASE
14732 XrmSetDatabase (dpyinfo
->display
, xrdb
);
14734 dpyinfo
->display
->db
= xrdb
;
14736 /* Put the rdb where we can find it in a way that works on
14738 dpyinfo
->xrdb
= xrdb
;
14740 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
14741 DefaultScreen (dpyinfo
->display
));
14742 select_visual (dpyinfo
);
14743 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
14744 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
14745 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
14746 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
14747 dpyinfo
->grabbed
= 0;
14748 dpyinfo
->reference_count
= 0;
14749 dpyinfo
->icon_bitmap_id
= -1;
14750 dpyinfo
->font_table
= NULL
;
14751 dpyinfo
->n_fonts
= 0;
14752 dpyinfo
->font_table_size
= 0;
14753 dpyinfo
->bitmaps
= 0;
14754 dpyinfo
->bitmaps_size
= 0;
14755 dpyinfo
->bitmaps_last
= 0;
14756 dpyinfo
->scratch_cursor_gc
= 0;
14757 dpyinfo
->mouse_face_mouse_frame
= 0;
14758 dpyinfo
->mouse_face_deferred_gc
= 0;
14759 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
14760 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
14761 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
14762 dpyinfo
->mouse_face_window
= Qnil
;
14763 dpyinfo
->mouse_face_overlay
= Qnil
;
14764 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
14765 dpyinfo
->mouse_face_defer
= 0;
14766 dpyinfo
->mouse_face_hidden
= 0;
14767 dpyinfo
->x_focus_frame
= 0;
14768 dpyinfo
->x_focus_event_frame
= 0;
14769 dpyinfo
->x_highlight_frame
= 0;
14770 dpyinfo
->image_cache
= make_image_cache ();
14772 /* See if a private colormap is requested. */
14773 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
14775 if (dpyinfo
->visual
->class == PseudoColor
)
14778 value
= display_x_get_resource (dpyinfo
,
14779 build_string ("privateColormap"),
14780 build_string ("PrivateColormap"),
14782 if (STRINGP (value
)
14783 && (!strcmp (XSTRING (value
)->data
, "true")
14784 || !strcmp (XSTRING (value
)->data
, "on")))
14785 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
14789 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
14790 dpyinfo
->visual
, AllocNone
);
14793 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
14794 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
14795 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
14796 dpyinfo
->resy
= pixels
* 25.4 / mm
;
14797 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
14798 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
14799 dpyinfo
->resx
= pixels
* 25.4 / mm
;
14802 dpyinfo
->Xatom_wm_protocols
14803 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
14804 dpyinfo
->Xatom_wm_take_focus
14805 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
14806 dpyinfo
->Xatom_wm_save_yourself
14807 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
14808 dpyinfo
->Xatom_wm_delete_window
14809 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
14810 dpyinfo
->Xatom_wm_change_state
14811 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
14812 dpyinfo
->Xatom_wm_configure_denied
14813 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
14814 dpyinfo
->Xatom_wm_window_moved
14815 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
14816 dpyinfo
->Xatom_editres
14817 = XInternAtom (dpyinfo
->display
, "Editres", False
);
14818 dpyinfo
->Xatom_CLIPBOARD
14819 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
14820 dpyinfo
->Xatom_TIMESTAMP
14821 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
14822 dpyinfo
->Xatom_TEXT
14823 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
14824 dpyinfo
->Xatom_COMPOUND_TEXT
14825 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
14826 dpyinfo
->Xatom_DELETE
14827 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
14828 dpyinfo
->Xatom_MULTIPLE
14829 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
14830 dpyinfo
->Xatom_INCR
14831 = XInternAtom (dpyinfo
->display
, "INCR", False
);
14832 dpyinfo
->Xatom_EMACS_TMP
14833 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
14834 dpyinfo
->Xatom_TARGETS
14835 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
14836 dpyinfo
->Xatom_NULL
14837 = XInternAtom (dpyinfo
->display
, "NULL", False
);
14838 dpyinfo
->Xatom_ATOM_PAIR
14839 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
14840 /* For properties of font. */
14841 dpyinfo
->Xatom_PIXEL_SIZE
14842 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
14843 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
14844 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
14845 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
14846 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
14847 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
14848 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
14850 /* Ghostscript support. */
14851 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
14852 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
14854 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
14857 dpyinfo
->cut_buffers_initialized
= 0;
14859 connection
= ConnectionNumber (dpyinfo
->display
);
14860 dpyinfo
->connection
= connection
;
14865 null_bits
[0] = 0x00;
14867 dpyinfo
->null_pixel
14868 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
14869 null_bits
, 1, 1, (long) 0, (long) 0,
14874 extern int gray_bitmap_width
, gray_bitmap_height
;
14875 extern char *gray_bitmap_bits
;
14877 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
14879 gray_bitmap_width
, gray_bitmap_height
,
14880 (unsigned long) 1, (unsigned long) 0, 1);
14884 xim_initialize (dpyinfo
, resource_name
);
14887 #ifdef subprocesses
14888 /* This is only needed for distinguishing keyboard and process input. */
14889 if (connection
!= 0)
14890 add_keyboard_wait_descriptor (connection
);
14893 #ifndef F_SETOWN_BUG
14895 #ifdef F_SETOWN_SOCK_NEG
14896 /* stdin is a socket here */
14897 fcntl (connection
, F_SETOWN
, -getpid ());
14898 #else /* ! defined (F_SETOWN_SOCK_NEG) */
14899 fcntl (connection
, F_SETOWN
, getpid ());
14900 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
14901 #endif /* ! defined (F_SETOWN) */
14902 #endif /* F_SETOWN_BUG */
14905 if (interrupt_input
)
14906 init_sigio (connection
);
14907 #endif /* ! defined (SIGIO) */
14910 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
14911 /* Make sure that we have a valid font for dialog boxes
14912 so that Xt does not crash. */
14914 Display
*dpy
= dpyinfo
->display
;
14915 XrmValue d
, fr
, to
;
14919 d
.addr
= (XPointer
)&dpy
;
14920 d
.size
= sizeof (Display
*);
14921 fr
.addr
= XtDefaultFont
;
14922 fr
.size
= sizeof (XtDefaultFont
);
14923 to
.size
= sizeof (Font
*);
14924 to
.addr
= (XPointer
)&font
;
14925 count
= x_catch_errors (dpy
);
14926 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
14928 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
14929 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
14930 x_uncatch_errors (dpy
, count
);
14935 /* See if we should run in synchronous mode. This is useful
14936 for debugging X code. */
14939 value
= display_x_get_resource (dpyinfo
,
14940 build_string ("synchronous"),
14941 build_string ("Synchronous"),
14943 if (STRINGP (value
)
14944 && (!strcmp (XSTRING (value
)->data
, "true")
14945 || !strcmp (XSTRING (value
)->data
, "on")))
14946 XSynchronize (dpyinfo
->display
, True
);
14954 /* Get rid of display DPYINFO, assuming all frames are already gone,
14955 and without sending any more commands to the X server. */
14958 x_delete_display (dpyinfo
)
14959 struct x_display_info
*dpyinfo
;
14961 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
14963 /* Discard this display from x_display_name_list and x_display_list.
14964 We can't use Fdelq because that can quit. */
14965 if (! NILP (x_display_name_list
)
14966 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
14967 x_display_name_list
= XCDR (x_display_name_list
);
14972 tail
= x_display_name_list
;
14973 while (CONSP (tail
) && CONSP (XCDR (tail
)))
14975 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
14977 XSETCDR (tail
, XCDR (XCDR (tail
)));
14980 tail
= XCDR (tail
);
14984 if (next_noop_dpyinfo
== dpyinfo
)
14985 next_noop_dpyinfo
= dpyinfo
->next
;
14987 if (x_display_list
== dpyinfo
)
14988 x_display_list
= dpyinfo
->next
;
14991 struct x_display_info
*tail
;
14993 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
14994 if (tail
->next
== dpyinfo
)
14995 tail
->next
= tail
->next
->next
;
14998 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
14999 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
15000 XrmDestroyDatabase (dpyinfo
->xrdb
);
15003 #ifdef MULTI_KBOARD
15004 if (--dpyinfo
->kboard
->reference_count
== 0)
15005 delete_kboard (dpyinfo
->kboard
);
15009 xim_close_dpy (dpyinfo
);
15012 xfree (dpyinfo
->font_table
);
15013 xfree (dpyinfo
->x_id_name
);
15014 xfree (dpyinfo
->color_cells
);
15019 /* Set up use of X before we make the first connection. */
15021 static struct redisplay_interface x_redisplay_interface
=
15026 x_clear_end_of_line
,
15028 x_after_update_window_line
,
15029 x_update_window_begin
,
15030 x_update_window_end
,
15033 x_clear_mouse_face
,
15034 x_get_glyph_overhangs
,
15035 x_fix_overlapping_area
15041 rif
= &x_redisplay_interface
;
15043 clear_frame_hook
= x_clear_frame
;
15044 ins_del_lines_hook
= x_ins_del_lines
;
15045 delete_glyphs_hook
= x_delete_glyphs
;
15046 ring_bell_hook
= XTring_bell
;
15047 reset_terminal_modes_hook
= XTreset_terminal_modes
;
15048 set_terminal_modes_hook
= XTset_terminal_modes
;
15049 update_begin_hook
= x_update_begin
;
15050 update_end_hook
= x_update_end
;
15051 set_terminal_window_hook
= XTset_terminal_window
;
15052 read_socket_hook
= XTread_socket
;
15053 frame_up_to_date_hook
= XTframe_up_to_date
;
15054 mouse_position_hook
= XTmouse_position
;
15055 frame_rehighlight_hook
= XTframe_rehighlight
;
15056 frame_raise_lower_hook
= XTframe_raise_lower
;
15057 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
15058 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
15059 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
15060 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
15061 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
15063 scroll_region_ok
= 1; /* we'll scroll partial frames */
15064 char_ins_del_ok
= 1;
15065 line_ins_del_ok
= 1; /* we'll just blt 'em */
15066 fast_clear_end_of_line
= 1; /* X does this well */
15067 memory_below_frame
= 0; /* we don't remember what scrolls
15072 last_tool_bar_item
= -1;
15073 any_help_event_p
= 0;
15075 /* Try to use interrupt input; if we can't, then start polling. */
15076 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
15078 #ifdef USE_X_TOOLKIT
15079 XtToolkitInitialize ();
15081 Xt_app_con
= XtCreateApplicationContext ();
15083 /* Register a converter from strings to pixels, which uses
15084 Emacs' color allocation infrastructure. */
15085 XtAppSetTypeConverter (Xt_app_con
,
15086 XtRString
, XtRPixel
, cvt_string_to_pixel
,
15087 cvt_string_to_pixel_args
,
15088 XtNumber (cvt_string_to_pixel_args
),
15089 XtCacheByDisplay
, cvt_pixel_dtor
);
15091 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
15093 /* Install an asynchronous timer that processes Xt timeout events
15094 every 0.1s. This is necessary because some widget sets use
15095 timeouts internally, for example the LessTif menu bar, or the
15096 Xaw3d scroll bar. When Xt timouts aren't processed, these
15097 widgets don't behave normally. */
15099 EMACS_TIME interval
;
15100 EMACS_SET_SECS_USECS (interval
, 0, 100000);
15101 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
15105 #ifdef USE_TOOLKIT_SCROLL_BARS
15106 xaw3d_arrow_scroll
= False
;
15107 xaw3d_pick_top
= True
;
15110 /* Note that there is no real way portable across R3/R4 to get the
15111 original error handler. */
15112 XSetErrorHandler (x_error_handler
);
15113 XSetIOErrorHandler (x_io_error_quitter
);
15115 /* Disable Window Change signals; they are handled by X events. */
15117 signal (SIGWINCH
, SIG_DFL
);
15118 #endif /* SIGWINCH */
15120 signal (SIGPIPE
, x_connection_signal
);
15123 x_session_initialize ();
15131 staticpro (&x_error_message_string
);
15132 x_error_message_string
= Qnil
;
15134 staticpro (&x_display_name_list
);
15135 x_display_name_list
= Qnil
;
15137 staticpro (&last_mouse_scroll_bar
);
15138 last_mouse_scroll_bar
= Qnil
;
15140 staticpro (&Qvendor_specific_keysyms
);
15141 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
15143 staticpro (&Qutf_8
);
15144 Qutf_8
= intern ("utf-8");
15145 staticpro (&Qlatin_1
);
15146 Qlatin_1
= intern ("latin-1");
15148 staticpro (&last_mouse_press_frame
);
15149 last_mouse_press_frame
= Qnil
;
15152 staticpro (&help_echo
);
15153 help_echo_object
= Qnil
;
15154 staticpro (&help_echo_object
);
15155 help_echo_window
= Qnil
;
15156 staticpro (&help_echo_window
);
15157 previous_help_echo
= Qnil
;
15158 staticpro (&previous_help_echo
);
15159 help_echo_pos
= -1;
15161 DEFVAR_BOOL ("mouse-autoselect-window", &mouse_autoselect_window
,
15162 doc
: /* *Non-nil means autoselect window with mouse pointer. */);
15163 mouse_autoselect_window
= 0;
15165 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
15166 doc
: /* *Non-nil means draw block cursor as wide as the glyph under it.
15167 For example, if a block cursor is over a tab, it will be drawn as
15168 wide as that tab on the display. */);
15169 x_stretch_cursor_p
= 0;
15171 DEFVAR_BOOL ("x-use-underline-position-properties",
15172 &x_use_underline_position_properties
,
15173 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
15174 nil means ignore them. If you encounter fonts with bogus
15175 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
15176 to 4.1, set this to nil. */);
15177 x_use_underline_position_properties
= 1;
15179 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
15180 doc
: /* What X toolkit scroll bars Emacs uses.
15181 A value of nil means Emacs doesn't use X toolkit scroll bars.
15182 Otherwise, value is a symbol describing the X toolkit. */);
15183 #ifdef USE_TOOLKIT_SCROLL_BARS
15185 Vx_toolkit_scroll_bars
= intern ("motif");
15186 #elif defined HAVE_XAW3D
15187 Vx_toolkit_scroll_bars
= intern ("xaw3d");
15189 Vx_toolkit_scroll_bars
= intern ("xaw");
15192 Vx_toolkit_scroll_bars
= Qnil
;
15195 staticpro (&last_mouse_motion_frame
);
15196 last_mouse_motion_frame
= Qnil
;
15198 Qmodifier_value
= intern ("modifier-value");
15199 Qalt
= intern ("alt");
15200 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
15201 Qhyper
= intern ("hyper");
15202 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
15203 Qmeta
= intern ("meta");
15204 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
15205 Qsuper
= intern ("super");
15206 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
15208 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
15209 doc
: /* Which keys Emacs uses for the alt modifier.
15210 This should be one of the symbols `alt', `hyper', `meta', `super'.
15211 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
15212 is nil, which is the same as `alt'. */);
15213 Vx_alt_keysym
= Qnil
;
15215 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
15216 doc
: /* Which keys Emacs uses for the hyper modifier.
15217 This should be one of the symbols `alt', `hyper', `meta', `super'.
15218 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
15219 default is nil, which is the same as `hyper'. */);
15220 Vx_hyper_keysym
= Qnil
;
15222 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
15223 doc
: /* Which keys Emacs uses for the meta modifier.
15224 This should be one of the symbols `alt', `hyper', `meta', `super'.
15225 For example, `meta' means use the Meta_L and Meta_R keysyms. The
15226 default is nil, which is the same as `meta'. */);
15227 Vx_meta_keysym
= Qnil
;
15229 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
15230 doc
: /* Which keys Emacs uses for the super modifier.
15231 This should be one of the symbols `alt', `hyper', `meta', `super'.
15232 For example, `super' means use the Super_L and Super_R keysyms. The
15233 default is nil, which is the same as `super'. */);
15234 Vx_super_keysym
= Qnil
;
15238 #endif /* HAVE_X_WINDOWS */