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
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 int x_focus_changed
P_ ((int,
471 struct x_display_info
*,
473 struct input_event
*,
475 static int x_detect_focus_change
P_ ((struct x_display_info
*,
477 struct input_event
*,
479 static void XTframe_rehighlight
P_ ((struct frame
*));
480 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
481 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
482 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
483 enum text_cursor_kinds
));
484 static int x_intersect_rectangles
P_ ((XRectangle
*, XRectangle
*,
486 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
487 static int expose_window_tree
P_ ((struct window
*, XRectangle
*));
488 static int expose_window
P_ ((struct window
*, XRectangle
*));
489 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
490 XRectangle
*, enum glyph_row_area
));
491 static int expose_line
P_ ((struct window
*, struct glyph_row
*,
493 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
494 static void x_update_window_cursor
P_ ((struct window
*, int));
495 static void x_erase_phys_cursor
P_ ((struct window
*));
496 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
497 static void x_draw_fringe_bitmap
P_ ((struct window
*, struct glyph_row
*,
498 enum fringe_bitmap_type
, int left_p
));
500 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
502 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, XRectangle
*));
503 static void x_draw_row_fringe_bitmaps
P_ ((struct window
*, struct glyph_row
*));
504 static void notice_overwritten_cursor
P_ ((struct window
*, enum glyph_row_area
,
505 int, int, int, int));
506 static void x_flush
P_ ((struct frame
*f
));
507 static void x_update_begin
P_ ((struct frame
*));
508 static void x_update_window_begin
P_ ((struct window
*));
509 static void x_draw_vertical_border
P_ ((struct window
*));
510 static void x_after_update_window_line
P_ ((struct glyph_row
*));
511 static INLINE
void take_vertical_position_into_account
P_ ((struct it
*));
512 static void x_produce_stretch_glyph
P_ ((struct it
*));
513 static struct scroll_bar
*x_window_to_scroll_bar
P_ ((Window
));
514 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
515 enum scroll_bar_part
*,
516 Lisp_Object
*, Lisp_Object
*,
518 static void x_check_fullscreen
P_ ((struct frame
*));
519 static void x_check_fullscreen_move
P_ ((struct frame
*));
521 /* Flush display of frame F, or of all frames if F is null. */
530 Lisp_Object rest
, frame
;
531 FOR_EACH_FRAME (rest
, frame
)
532 x_flush (XFRAME (frame
));
534 else if (FRAME_X_P (f
))
535 XFlush (FRAME_X_DISPLAY (f
));
540 /* Remove calls to XFlush by defining XFlush to an empty replacement.
541 Calls to XFlush should be unnecessary because the X output buffer
542 is flushed automatically as needed by calls to XPending,
543 XNextEvent, or XWindowEvent according to the XFlush man page.
544 XTread_socket calls XPending. Removing XFlush improves
547 #define XFlush(DISPLAY) (void) 0
550 /***********************************************************************
552 ***********************************************************************/
556 /* This is a function useful for recording debugging information about
557 the sequence of occurrences in this file. */
565 struct record event_record
[100];
567 int event_record_index
;
569 record_event (locus
, type
)
573 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
574 event_record_index
= 0;
576 event_record
[event_record_index
].locus
= locus
;
577 event_record
[event_record_index
].type
= type
;
578 event_record_index
++;
585 /* Return the struct x_display_info corresponding to DPY. */
587 struct x_display_info
*
588 x_display_info_for_display (dpy
)
591 struct x_display_info
*dpyinfo
;
593 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
594 if (dpyinfo
->display
== dpy
)
602 /***********************************************************************
603 Starting and ending an update
604 ***********************************************************************/
606 /* Start an update of frame F. This function is installed as a hook
607 for update_begin, i.e. it is called when update_begin is called.
608 This function is called prior to calls to x_update_window_begin for
609 each window being updated. Currently, there is nothing to do here
610 because all interesting stuff is done on a window basis. */
620 /* Start update of window W. Set the global variable updated_window
621 to the window being updated and set output_cursor to the cursor
625 x_update_window_begin (w
)
628 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
629 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
632 set_output_cursor (&w
->cursor
);
636 if (f
== display_info
->mouse_face_mouse_frame
)
638 /* Don't do highlighting for mouse motion during the update. */
639 display_info
->mouse_face_defer
= 1;
641 /* If F needs to be redrawn, simply forget about any prior mouse
643 if (FRAME_GARBAGED_P (f
))
644 display_info
->mouse_face_window
= Qnil
;
646 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
647 their mouse_face_p flag set, which means that they are always
648 unequal to rows in a desired matrix which never have that
649 flag set. So, rows containing mouse-face glyphs are never
650 scrolled, and we don't have to switch the mouse highlight off
651 here to prevent it from being scrolled. */
653 /* Can we tell that this update does not affect the window
654 where the mouse highlight is? If so, no need to turn off.
655 Likewise, don't do anything if the frame is garbaged;
656 in that case, the frame's current matrix that we would use
657 is all wrong, and we will redisplay that line anyway. */
658 if (!NILP (display_info
->mouse_face_window
)
659 && w
== XWINDOW (display_info
->mouse_face_window
))
663 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
664 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
667 if (i
< w
->desired_matrix
->nrows
)
668 clear_mouse_face (display_info
);
677 /* Draw a vertical window border to the right of window W if W doesn't
678 have vertical scroll bars. */
681 x_draw_vertical_border (w
)
684 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
686 /* Redraw borders between horizontally adjacent windows. Don't
687 do it for frames with vertical scroll bars because either the
688 right scroll bar of a window, or the left scroll bar of its
689 neighbor will suffice as a border. */
690 if (!WINDOW_RIGHTMOST_P (w
)
691 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
695 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
696 x1
+= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
699 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
700 f
->output_data
.x
->normal_gc
, x1
, y0
, x1
, y1
);
705 /* End update of window W (which is equal to updated_window).
707 Draw vertical borders between horizontally adjacent windows, and
708 display W's cursor if CURSOR_ON_P is non-zero.
710 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
711 glyphs in mouse-face were overwritten. In that case we have to
712 make sure that the mouse-highlight is properly redrawn.
714 W may be a menu bar pseudo-window in case we don't have X toolkit
715 support. Such windows don't have a cursor, so don't display it
719 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
721 int cursor_on_p
, mouse_face_overwritten_p
;
723 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
725 if (!w
->pseudo_window_p
)
730 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
732 output_cursor
.x
, output_cursor
.y
);
734 x_draw_vertical_border (w
);
738 /* If a row with mouse-face was overwritten, arrange for
739 XTframe_up_to_date to redisplay the mouse highlight. */
740 if (mouse_face_overwritten_p
)
742 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
743 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
744 dpyinfo
->mouse_face_window
= Qnil
;
747 updated_window
= NULL
;
751 /* End update of frame F. This function is installed as a hook in
758 /* Mouse highlight may be displayed again. */
759 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
762 XFlush (FRAME_X_DISPLAY (f
));
767 /* This function is called from various places in xdisp.c whenever a
768 complete update has been performed. The global variable
769 updated_window is not available here. */
772 XTframe_up_to_date (f
)
777 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
779 if (dpyinfo
->mouse_face_deferred_gc
780 || f
== dpyinfo
->mouse_face_mouse_frame
)
783 if (dpyinfo
->mouse_face_mouse_frame
)
784 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
785 dpyinfo
->mouse_face_mouse_x
,
786 dpyinfo
->mouse_face_mouse_y
);
787 dpyinfo
->mouse_face_deferred_gc
= 0;
794 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
795 arrow bitmaps, or clear the fringes if no bitmaps are required
796 before DESIRED_ROW is made current. The window being updated is
797 found in updated_window. This function It is called from
798 update_window_line only if it is known that there are differences
799 between bitmaps to be drawn between current row and DESIRED_ROW. */
802 x_after_update_window_line (desired_row
)
803 struct glyph_row
*desired_row
;
805 struct window
*w
= updated_window
;
811 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
814 x_draw_row_fringe_bitmaps (w
, desired_row
);
818 /* When a window has disappeared, make sure that no rest of
819 full-width rows stays visible in the internal border. Could
820 check here if updated_window is the leftmost/rightmost window,
821 but I guess it's not worth doing since vertically split windows
822 are almost never used, internal border is rarely set, and the
823 overhead is very small. */
824 if (windows_or_buffers_changed
825 && desired_row
->full_width_p
826 && (f
= XFRAME (w
->frame
),
827 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
829 && (height
= desired_row
->visible_height
,
832 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
834 /* Internal border is drawn below the tool bar. */
835 if (WINDOWP (f
->tool_bar_window
)
836 && w
== XWINDOW (f
->tool_bar_window
))
840 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
841 0, y
, width
, height
, False
);
842 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
843 f
->output_data
.x
->pixel_width
- width
,
844 y
, width
, height
, False
);
850 /* Draw the bitmap WHICH in one of the left or right fringes of
851 window W. ROW is the glyph row for which to display the bitmap; it
852 determines the vertical position at which the bitmap has to be
856 x_draw_fringe_bitmap (w
, row
, which
, left_p
)
858 struct glyph_row
*row
;
859 enum fringe_bitmap_type which
;
862 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
863 Display
*display
= FRAME_X_DISPLAY (f
);
864 Window window
= FRAME_X_WINDOW (f
);
867 unsigned char *bits
= NULL
;
869 GC gc
= f
->output_data
.x
->normal_gc
;
871 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
873 /* Must clip because of partially visible lines. */
874 x_clip_to_row (w
, row
, gc
, 1);
876 /* Convert row to frame coordinates. */
877 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
881 case NO_FRINGE_BITMAP
:
886 case LEFT_TRUNCATION_BITMAP
:
892 case OVERLAY_ARROW_BITMAP
:
898 case RIGHT_TRUNCATION_BITMAP
:
904 case CONTINUED_LINE_BITMAP
:
905 wd
= continued_width
;
906 h
= continued_height
;
907 bits
= continued_bits
;
910 case CONTINUATION_LINE_BITMAP
:
911 wd
= continuation_width
;
912 h
= continuation_height
;
913 bits
= continuation_bits
;
918 h
= zv_height
- (y
% zv_period
);
919 bits
= zv_bits
+ (y
% zv_period
);
926 /* Clip bitmap if too high. */
930 /* Set dy to the offset in the row to start drawing the bitmap. */
931 dy
= (row
->height
- h
) / 2;
933 face
= FACE_FROM_ID (f
, FRINGE_FACE_ID
);
934 PREPARE_FACE_FOR_DISPLAY (f
, face
);
936 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
941 if (wd
> FRAME_X_LEFT_FRINGE_WIDTH (f
))
942 wd
= FRAME_X_LEFT_FRINGE_WIDTH (f
);
943 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
945 - (FRAME_X_LEFT_FRINGE_WIDTH (f
) - wd
) / 2);
946 if (wd
< FRAME_X_LEFT_FRINGE_WIDTH (f
) || row
->height
> h
)
948 /* If W has a vertical border to its left, don't draw over it. */
949 int border
= ((XFASTINT (w
->left
) > 0
950 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
952 b1
= (window_box_left (w
, -1)
953 - FRAME_X_LEFT_FRINGE_WIDTH (f
)
955 b2
= (FRAME_X_LEFT_FRINGE_WIDTH (f
) - border
);
960 if (wd
> FRAME_X_RIGHT_FRINGE_WIDTH (f
))
961 wd
= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
962 x
= (window_box_right (w
, -1)
963 + (FRAME_X_RIGHT_FRINGE_WIDTH (f
) - wd
) / 2);
964 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
966 if (wd
< FRAME_X_RIGHT_FRINGE_WIDTH (f
) || row
->height
> h
)
968 b1
= window_box_right (w
, -1);
969 b2
= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
975 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
977 /* In case the same realized face is used for fringes and
978 for something displayed in the text (e.g. face `region' on
979 mono-displays, the fill style may have been changed to
980 FillSolid in x_draw_glyph_string_background. */
982 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
984 XSetForeground (display
, face
->gc
, face
->background
);
986 XFillRectangle (display
, window
, face
->gc
,
988 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
991 row
->visible_height
);
993 XSetForeground (display
, face
->gc
, face
->foreground
);
996 if (which
!= NO_FRINGE_BITMAP
)
998 /* Draw the bitmap. I believe these small pixmaps can be cached
1000 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, wd
, h
,
1002 face
->background
, depth
);
1003 XCopyArea (display
, pixmap
, window
, gc
, 0, 0, wd
, h
, x
, y
+ dy
);
1004 XFreePixmap (display
, pixmap
);
1007 XSetClipMask (display
, gc
, None
);
1011 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
1012 function with input blocked. */
1015 x_draw_row_fringe_bitmaps (w
, row
)
1017 struct glyph_row
*row
;
1019 struct frame
*f
= XFRAME (w
->frame
);
1020 enum fringe_bitmap_type bitmap
;
1022 xassert (interrupt_input_blocked
);
1024 /* If row is completely invisible, because of vscrolling, we
1025 don't have to draw anything. */
1026 if (row
->visible_height
<= 0)
1029 if (FRAME_X_LEFT_FRINGE_WIDTH (f
) != 0)
1031 /* Decide which bitmap to draw in the left fringe. */
1032 if (row
->overlay_arrow_p
)
1033 bitmap
= OVERLAY_ARROW_BITMAP
;
1034 else if (row
->truncated_on_left_p
)
1035 bitmap
= LEFT_TRUNCATION_BITMAP
;
1036 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
1037 bitmap
= CONTINUATION_LINE_BITMAP
;
1038 else if (row
->indicate_empty_line_p
)
1039 bitmap
= ZV_LINE_BITMAP
;
1041 bitmap
= NO_FRINGE_BITMAP
;
1043 x_draw_fringe_bitmap (w
, row
, bitmap
, 1);
1046 if (FRAME_X_RIGHT_FRINGE_WIDTH (f
) != 0)
1048 /* Decide which bitmap to draw in the right fringe. */
1049 if (row
->truncated_on_right_p
)
1050 bitmap
= RIGHT_TRUNCATION_BITMAP
;
1051 else if (row
->continued_p
)
1052 bitmap
= CONTINUED_LINE_BITMAP
;
1053 else if (row
->indicate_empty_line_p
&& FRAME_X_LEFT_FRINGE_WIDTH (f
) == 0)
1054 bitmap
= ZV_LINE_BITMAP
;
1056 bitmap
= NO_FRINGE_BITMAP
;
1058 x_draw_fringe_bitmap (w
, row
, bitmap
, 0);
1064 /* This is called when starting Emacs and when restarting after
1065 suspend. When starting Emacs, no X window is mapped. And nothing
1066 must be done to Emacs's own window if it is suspended (though that
1070 XTset_terminal_modes ()
1074 /* This is called when exiting or suspending Emacs. Exiting will make
1075 the X-windows go away, and suspending requires no action. */
1078 XTreset_terminal_modes ()
1084 /***********************************************************************
1086 ***********************************************************************/
1088 /* Set the global variable output_cursor to CURSOR. All cursor
1089 positions are relative to updated_window. */
1092 set_output_cursor (cursor
)
1093 struct cursor_pos
*cursor
;
1095 output_cursor
.hpos
= cursor
->hpos
;
1096 output_cursor
.vpos
= cursor
->vpos
;
1097 output_cursor
.x
= cursor
->x
;
1098 output_cursor
.y
= cursor
->y
;
1102 /* Set a nominal cursor position.
1104 HPOS and VPOS are column/row positions in a window glyph matrix. X
1105 and Y are window text area relative pixel positions.
1107 If this is done during an update, updated_window will contain the
1108 window that is being updated and the position is the future output
1109 cursor position for that window. If updated_window is null, use
1110 selected_window and display the cursor at the given position. */
1113 XTcursor_to (vpos
, hpos
, y
, x
)
1114 int vpos
, hpos
, y
, x
;
1118 /* If updated_window is not set, work on selected_window. */
1122 w
= XWINDOW (selected_window
);
1124 /* Set the output cursor. */
1125 output_cursor
.hpos
= hpos
;
1126 output_cursor
.vpos
= vpos
;
1127 output_cursor
.x
= x
;
1128 output_cursor
.y
= y
;
1130 /* If not called as part of an update, really display the cursor.
1131 This will also set the cursor position of W. */
1132 if (updated_window
== NULL
)
1135 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1136 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1143 /***********************************************************************
1145 ***********************************************************************/
1147 /* Function prototypes of this page. */
1149 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1153 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1154 int, XChar2b
*, int,
1156 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
1157 static void x_encode_char
P_ ((int, XChar2b
*, struct font_info
*));
1158 static void x_append_glyph
P_ ((struct it
*));
1159 static void x_append_composite_glyph
P_ ((struct it
*));
1160 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1162 static void x_produce_glyphs
P_ ((struct it
*));
1163 static void x_produce_image_glyph
P_ ((struct it
*it
));
1166 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1167 is not contained in the font. */
1169 static INLINE XCharStruct
*
1170 x_per_char_metric (font
, char2b
)
1174 /* The result metric information. */
1175 XCharStruct
*pcm
= NULL
;
1177 xassert (font
&& char2b
);
1179 if (font
->per_char
!= NULL
)
1181 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
1183 /* min_char_or_byte2 specifies the linear character index
1184 corresponding to the first element of the per_char array,
1185 max_char_or_byte2 is the index of the last character. A
1186 character with non-zero CHAR2B->byte1 is not in the font.
1187 A character with byte2 less than min_char_or_byte2 or
1188 greater max_char_or_byte2 is not in the font. */
1189 if (char2b
->byte1
== 0
1190 && char2b
->byte2
>= font
->min_char_or_byte2
1191 && char2b
->byte2
<= font
->max_char_or_byte2
)
1192 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
1196 /* If either min_byte1 or max_byte1 are nonzero, both
1197 min_char_or_byte2 and max_char_or_byte2 are less than
1198 256, and the 2-byte character index values corresponding
1199 to the per_char array element N (counting from 0) are:
1201 byte1 = N/D + min_byte1
1202 byte2 = N\D + min_char_or_byte2
1206 D = max_char_or_byte2 - min_char_or_byte2 + 1
1207 / = integer division
1208 \ = integer modulus */
1209 if (char2b
->byte1
>= font
->min_byte1
1210 && char2b
->byte1
<= font
->max_byte1
1211 && char2b
->byte2
>= font
->min_char_or_byte2
1212 && char2b
->byte2
<= font
->max_char_or_byte2
)
1214 pcm
= (font
->per_char
1215 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
1216 * (char2b
->byte1
- font
->min_byte1
))
1217 + (char2b
->byte2
- font
->min_char_or_byte2
));
1223 /* If the per_char pointer is null, all glyphs between the first
1224 and last character indexes inclusive have the same
1225 information, as given by both min_bounds and max_bounds. */
1226 if (char2b
->byte2
>= font
->min_char_or_byte2
1227 && char2b
->byte2
<= font
->max_char_or_byte2
)
1228 pcm
= &font
->max_bounds
;
1231 return ((pcm
== NULL
1232 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
1237 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1238 the two-byte form of C. Encoding is returned in *CHAR2B. */
1241 x_encode_char (c
, char2b
, font_info
)
1244 struct font_info
*font_info
;
1246 int charset
= CHAR_CHARSET (c
);
1247 XFontStruct
*font
= font_info
->font
;
1249 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1250 This may be either a program in a special encoder language or a
1252 if (font_info
->font_encoder
)
1254 /* It's a program. */
1255 struct ccl_program
*ccl
= font_info
->font_encoder
;
1257 if (CHARSET_DIMENSION (charset
) == 1)
1259 ccl
->reg
[0] = charset
;
1260 ccl
->reg
[1] = char2b
->byte2
;
1264 ccl
->reg
[0] = charset
;
1265 ccl
->reg
[1] = char2b
->byte1
;
1266 ccl
->reg
[2] = char2b
->byte2
;
1269 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1271 /* We assume that MSBs are appropriately set/reset by CCL
1273 if (font
->max_byte1
== 0) /* 1-byte font */
1274 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
1276 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
1278 else if (font_info
->encoding
[charset
])
1280 /* Fixed encoding scheme. See fontset.h for the meaning of the
1281 encoding numbers. */
1282 int enc
= font_info
->encoding
[charset
];
1284 if ((enc
== 1 || enc
== 2)
1285 && CHARSET_DIMENSION (charset
) == 2)
1286 char2b
->byte1
|= 0x80;
1288 if (enc
== 1 || enc
== 3)
1289 char2b
->byte2
|= 0x80;
1294 /* Get face and two-byte form of character C in face FACE_ID on frame
1295 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1296 means we want to display multibyte text. DISPLAY_P non-zero means
1297 make sure that X resources for the face returned are allocated.
1298 Value is a pointer to a realized face that is ready for display if
1299 DISPLAY_P is non-zero. */
1301 static INLINE
struct face
*
1302 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
, display_p
)
1306 int multibyte_p
, display_p
;
1308 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1312 /* Unibyte case. We don't have to encode, but we have to make
1313 sure to use a face suitable for unibyte. */
1316 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1317 face
= FACE_FROM_ID (f
, face_id
);
1319 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1321 /* Case of ASCII in a face known to fit ASCII. */
1327 int c1
, c2
, charset
;
1329 /* Split characters into bytes. If c2 is -1 afterwards, C is
1330 really a one-byte character so that byte1 is zero. */
1331 SPLIT_CHAR (c
, charset
, c1
, c2
);
1333 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1335 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1337 /* Maybe encode the character in *CHAR2B. */
1338 if (face
->font
!= NULL
)
1340 struct font_info
*font_info
1341 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1343 x_encode_char (c
, char2b
, font_info
);
1347 /* Make sure X resources of the face are allocated. */
1350 xassert (face
!= NULL
);
1351 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1358 /* Get face and two-byte form of character glyph GLYPH on frame F.
1359 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1360 a pointer to a realized face that is ready for display. */
1362 static INLINE
struct face
*
1363 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1365 struct glyph
*glyph
;
1371 xassert (glyph
->type
== CHAR_GLYPH
);
1372 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1377 if (!glyph
->multibyte_p
)
1379 /* Unibyte case. We don't have to encode, but we have to make
1380 sure to use a face suitable for unibyte. */
1382 char2b
->byte2
= glyph
->u
.ch
;
1384 else if (glyph
->u
.ch
< 128
1385 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1387 /* Case of ASCII in a face known to fit ASCII. */
1389 char2b
->byte2
= glyph
->u
.ch
;
1393 int c1
, c2
, charset
;
1395 /* Split characters into bytes. If c2 is -1 afterwards, C is
1396 really a one-byte character so that byte1 is zero. */
1397 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1399 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1401 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1403 /* Maybe encode the character in *CHAR2B. */
1404 if (charset
!= CHARSET_ASCII
)
1406 struct font_info
*font_info
1407 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1410 x_encode_char (glyph
->u
.ch
, char2b
, font_info
);
1413 = ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
1418 /* Make sure X resources of the face are allocated. */
1419 xassert (face
!= NULL
);
1420 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1425 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1426 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1432 struct glyph
*glyph
;
1433 enum glyph_row_area area
= it
->area
;
1435 xassert (it
->glyph_row
);
1436 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1438 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1439 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1441 glyph
->charpos
= CHARPOS (it
->position
);
1442 glyph
->object
= it
->object
;
1443 glyph
->pixel_width
= it
->pixel_width
;
1444 glyph
->voffset
= it
->voffset
;
1445 glyph
->type
= CHAR_GLYPH
;
1446 glyph
->multibyte_p
= it
->multibyte_p
;
1447 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1448 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1449 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1450 || it
->phys_descent
> it
->descent
);
1451 glyph
->padding_p
= 0;
1452 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1453 glyph
->face_id
= it
->face_id
;
1454 glyph
->u
.ch
= it
->char_to_display
;
1455 ++it
->glyph_row
->used
[area
];
1459 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1460 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1463 x_append_composite_glyph (it
)
1466 struct glyph
*glyph
;
1467 enum glyph_row_area area
= it
->area
;
1469 xassert (it
->glyph_row
);
1471 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1472 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1474 glyph
->charpos
= CHARPOS (it
->position
);
1475 glyph
->object
= it
->object
;
1476 glyph
->pixel_width
= it
->pixel_width
;
1477 glyph
->voffset
= it
->voffset
;
1478 glyph
->type
= COMPOSITE_GLYPH
;
1479 glyph
->multibyte_p
= it
->multibyte_p
;
1480 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1481 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1482 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1483 || it
->phys_descent
> it
->descent
);
1484 glyph
->padding_p
= 0;
1485 glyph
->glyph_not_available_p
= 0;
1486 glyph
->face_id
= it
->face_id
;
1487 glyph
->u
.cmp_id
= it
->cmp_id
;
1488 ++it
->glyph_row
->used
[area
];
1493 /* Change IT->ascent and IT->height according to the setting of
1497 take_vertical_position_into_account (it
)
1502 if (it
->voffset
< 0)
1503 /* Increase the ascent so that we can display the text higher
1505 it
->ascent
+= abs (it
->voffset
);
1507 /* Increase the descent so that we can display the text lower
1509 it
->descent
+= it
->voffset
;
1514 /* Produce glyphs/get display metrics for the image IT is loaded with.
1515 See the description of struct display_iterator in dispextern.h for
1516 an overview of struct display_iterator. */
1519 x_produce_image_glyph (it
)
1525 xassert (it
->what
== IT_IMAGE
);
1527 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1528 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1531 /* Make sure X resources of the face and image are loaded. */
1532 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1533 prepare_image_for_display (it
->f
, img
);
1535 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1536 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->vmargin
- it
->ascent
;
1537 it
->pixel_width
= img
->width
+ 2 * img
->hmargin
;
1541 if (face
->box
!= FACE_NO_BOX
)
1543 if (face
->box_line_width
> 0)
1545 it
->ascent
+= face
->box_line_width
;
1546 it
->descent
+= face
->box_line_width
;
1549 if (it
->start_of_box_run_p
)
1550 it
->pixel_width
+= abs (face
->box_line_width
);
1551 if (it
->end_of_box_run_p
)
1552 it
->pixel_width
+= abs (face
->box_line_width
);
1555 take_vertical_position_into_account (it
);
1559 struct glyph
*glyph
;
1560 enum glyph_row_area area
= it
->area
;
1562 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1563 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1565 glyph
->charpos
= CHARPOS (it
->position
);
1566 glyph
->object
= it
->object
;
1567 glyph
->pixel_width
= it
->pixel_width
;
1568 glyph
->voffset
= it
->voffset
;
1569 glyph
->type
= IMAGE_GLYPH
;
1570 glyph
->multibyte_p
= it
->multibyte_p
;
1571 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1572 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1573 glyph
->overlaps_vertically_p
= 0;
1574 glyph
->padding_p
= 0;
1575 glyph
->glyph_not_available_p
= 0;
1576 glyph
->face_id
= it
->face_id
;
1577 glyph
->u
.img_id
= img
->id
;
1578 ++it
->glyph_row
->used
[area
];
1584 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1585 of the glyph, WIDTH and HEIGHT are the width and height of the
1586 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1587 ascent of the glyph (0 <= ASCENT <= 1). */
1590 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1596 struct glyph
*glyph
;
1597 enum glyph_row_area area
= it
->area
;
1599 xassert (ascent
>= 0 && ascent
<= 1);
1601 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1602 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1604 glyph
->charpos
= CHARPOS (it
->position
);
1605 glyph
->object
= object
;
1606 glyph
->pixel_width
= width
;
1607 glyph
->voffset
= it
->voffset
;
1608 glyph
->type
= STRETCH_GLYPH
;
1609 glyph
->multibyte_p
= it
->multibyte_p
;
1610 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1611 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1612 glyph
->overlaps_vertically_p
= 0;
1613 glyph
->padding_p
= 0;
1614 glyph
->glyph_not_available_p
= 0;
1615 glyph
->face_id
= it
->face_id
;
1616 glyph
->u
.stretch
.ascent
= height
* ascent
;
1617 glyph
->u
.stretch
.height
= height
;
1618 ++it
->glyph_row
->used
[area
];
1623 /* Produce a stretch glyph for iterator IT. IT->object is the value
1624 of the glyph property displayed. The value must be a list
1625 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1628 1. `:width WIDTH' specifies that the space should be WIDTH *
1629 canonical char width wide. WIDTH may be an integer or floating
1632 2. `:relative-width FACTOR' specifies that the width of the stretch
1633 should be computed from the width of the first character having the
1634 `glyph' property, and should be FACTOR times that width.
1636 3. `:align-to HPOS' specifies that the space should be wide enough
1637 to reach HPOS, a value in canonical character units.
1639 Exactly one of the above pairs must be present.
1641 4. `:height HEIGHT' specifies that the height of the stretch produced
1642 should be HEIGHT, measured in canonical character units.
1644 5. `:relative-height FACTOR' specifies that the height of the
1645 stretch should be FACTOR times the height of the characters having
1648 Either none or exactly one of 4 or 5 must be present.
1650 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1651 of the stretch should be used for the ascent of the stretch.
1652 ASCENT must be in the range 0 <= ASCENT <= 100. */
1655 ((INTEGERP (X) || FLOATP (X)) \
1661 x_produce_stretch_glyph (it
)
1664 /* (space :width WIDTH :height HEIGHT. */
1666 extern Lisp_Object Qspace
;
1668 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
1669 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1670 extern Lisp_Object QCalign_to
;
1671 Lisp_Object prop
, plist
;
1672 double width
= 0, height
= 0, ascent
= 0;
1673 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1674 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1676 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1678 /* List should start with `space'. */
1679 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1680 plist
= XCDR (it
->object
);
1682 /* Compute the width of the stretch. */
1683 if (prop
= Fplist_get (plist
, QCwidth
),
1685 /* Absolute width `:width WIDTH' specified and valid. */
1686 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1687 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1690 /* Relative width `:relative-width FACTOR' specified and valid.
1691 Compute the width of the characters having the `glyph'
1694 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1697 if (it
->multibyte_p
)
1699 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1700 - IT_BYTEPOS (*it
));
1701 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1704 it2
.c
= *p
, it2
.len
= 1;
1706 it2
.glyph_row
= NULL
;
1707 it2
.what
= IT_CHARACTER
;
1708 x_produce_glyphs (&it2
);
1709 width
= NUMVAL (prop
) * it2
.pixel_width
;
1711 else if (prop
= Fplist_get (plist
, QCalign_to
),
1713 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1715 /* Nothing specified -> width defaults to canonical char width. */
1716 width
= CANON_X_UNIT (it
->f
);
1718 /* Compute height. */
1719 if (prop
= Fplist_get (plist
, QCheight
),
1721 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1722 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1724 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1726 height
= FONT_HEIGHT (font
);
1728 /* Compute percentage of height used for ascent. If
1729 `:ascent ASCENT' is present and valid, use that. Otherwise,
1730 derive the ascent from the font in use. */
1731 if (prop
= Fplist_get (plist
, QCascent
),
1732 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1733 ascent
= NUMVAL (prop
) / 100.0;
1735 ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1744 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1745 if (!STRINGP (object
))
1746 object
= it
->w
->buffer
;
1747 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1750 it
->pixel_width
= width
;
1751 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1752 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1755 if (face
->box
!= FACE_NO_BOX
)
1757 if (face
->box_line_width
> 0)
1759 it
->ascent
+= face
->box_line_width
;
1760 it
->descent
+= face
->box_line_width
;
1763 if (it
->start_of_box_run_p
)
1764 it
->pixel_width
+= abs (face
->box_line_width
);
1765 if (it
->end_of_box_run_p
)
1766 it
->pixel_width
+= abs (face
->box_line_width
);
1769 take_vertical_position_into_account (it
);
1772 /* Return proper value to be used as baseline offset of font that has
1773 ASCENT and DESCENT to draw characters by the font at the vertical
1774 center of the line of frame F.
1776 Here, out task is to find the value of BOFF in the following figure;
1778 -------------------------+-----------+-
1779 -+-+---------+-+ | |
1781 | | | | F_ASCENT F_HEIGHT
1784 | | |-|-+------+-----------|------- baseline
1786 | |---------|-+-+ | |
1788 -+-+---------+-+ F_DESCENT |
1789 -------------------------+-----------+-
1791 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1792 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1793 DESCENT = FONT->descent
1794 HEIGHT = FONT_HEIGHT (FONT)
1795 F_DESCENT = (F->output_data.x->font->descent
1796 - F->output_data.x->baseline_offset)
1797 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1800 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1802 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
1803 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
1804 - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
1806 /* Produce glyphs/get display metrics for the display element IT is
1807 loaded with. See the description of struct display_iterator in
1808 dispextern.h for an overview of struct display_iterator. */
1811 x_produce_glyphs (it
)
1814 it
->glyph_not_available_p
= 0;
1816 if (it
->what
== IT_CHARACTER
)
1820 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1822 int font_not_found_p
;
1823 struct font_info
*font_info
;
1824 int boff
; /* baseline offset */
1825 /* We may change it->multibyte_p upon unibyte<->multibyte
1826 conversion. So, save the current value now and restore it
1829 Note: It seems that we don't have to record multibyte_p in
1830 struct glyph because the character code itself tells if or
1831 not the character is multibyte. Thus, in the future, we must
1832 consider eliminating the field `multibyte_p' in the struct
1834 int saved_multibyte_p
= it
->multibyte_p
;
1836 /* Maybe translate single-byte characters to multibyte, or the
1838 it
->char_to_display
= it
->c
;
1839 if (!ASCII_BYTE_P (it
->c
))
1841 if (unibyte_display_via_language_environment
1842 && SINGLE_BYTE_CHAR_P (it
->c
)
1844 || !NILP (Vnonascii_translation_table
)))
1846 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
1847 it
->multibyte_p
= 1;
1848 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1849 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1851 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
1852 && !it
->multibyte_p
)
1854 it
->multibyte_p
= 1;
1855 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1856 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1860 /* Get font to use. Encode IT->char_to_display. */
1861 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
1862 it
->face_id
, &char2b
,
1863 it
->multibyte_p
, 0);
1866 /* When no suitable font found, use the default font. */
1867 font_not_found_p
= font
== NULL
;
1868 if (font_not_found_p
)
1870 font
= FRAME_FONT (it
->f
);
1871 boff
= it
->f
->output_data
.x
->baseline_offset
;
1876 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
1877 boff
= font_info
->baseline_offset
;
1878 if (font_info
->vertical_centering
)
1879 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
1882 if (it
->char_to_display
>= ' '
1883 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
1885 /* Either unibyte or ASCII. */
1890 pcm
= x_per_char_metric (font
, &char2b
);
1891 it
->ascent
= font
->ascent
+ boff
;
1892 it
->descent
= font
->descent
- boff
;
1896 it
->phys_ascent
= pcm
->ascent
+ boff
;
1897 it
->phys_descent
= pcm
->descent
- boff
;
1898 it
->pixel_width
= pcm
->width
;
1902 it
->glyph_not_available_p
= 1;
1903 it
->phys_ascent
= font
->ascent
+ boff
;
1904 it
->phys_descent
= font
->descent
- boff
;
1905 it
->pixel_width
= FONT_WIDTH (font
);
1908 /* If this is a space inside a region of text with
1909 `space-width' property, change its width. */
1910 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
1912 it
->pixel_width
*= XFLOATINT (it
->space_width
);
1914 /* If face has a box, add the box thickness to the character
1915 height. If character has a box line to the left and/or
1916 right, add the box line width to the character's width. */
1917 if (face
->box
!= FACE_NO_BOX
)
1919 int thick
= face
->box_line_width
;
1923 it
->ascent
+= thick
;
1924 it
->descent
+= thick
;
1929 if (it
->start_of_box_run_p
)
1930 it
->pixel_width
+= thick
;
1931 if (it
->end_of_box_run_p
)
1932 it
->pixel_width
+= thick
;
1935 /* If face has an overline, add the height of the overline
1936 (1 pixel) and a 1 pixel margin to the character height. */
1937 if (face
->overline_p
)
1940 take_vertical_position_into_account (it
);
1942 /* If we have to actually produce glyphs, do it. */
1947 /* Translate a space with a `space-width' property
1948 into a stretch glyph. */
1949 double ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1950 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1951 it
->ascent
+ it
->descent
, ascent
);
1954 x_append_glyph (it
);
1956 /* If characters with lbearing or rbearing are displayed
1957 in this line, record that fact in a flag of the
1958 glyph row. This is used to optimize X output code. */
1959 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
1960 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1963 else if (it
->char_to_display
== '\n')
1965 /* A newline has no width but we need the height of the line. */
1966 it
->pixel_width
= 0;
1968 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1969 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1971 if (face
->box
!= FACE_NO_BOX
1972 && face
->box_line_width
> 0)
1974 it
->ascent
+= face
->box_line_width
;
1975 it
->descent
+= face
->box_line_width
;
1978 else if (it
->char_to_display
== '\t')
1980 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
1981 int x
= it
->current_x
+ it
->continuation_lines_width
;
1982 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
1984 /* If the distance from the current position to the next tab
1985 stop is less than a canonical character width, use the
1986 tab stop after that. */
1987 if (next_tab_x
- x
< CANON_X_UNIT (it
->f
))
1988 next_tab_x
+= tab_width
;
1990 it
->pixel_width
= next_tab_x
- x
;
1992 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1993 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1997 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
1998 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1999 it
->ascent
+ it
->descent
, ascent
);
2004 /* A multi-byte character. Assume that the display width of the
2005 character is the width of the character multiplied by the
2006 width of the font. */
2008 /* If we found a font, this font should give us the right
2009 metrics. If we didn't find a font, use the frame's
2010 default font and calculate the width of the character
2011 from the charset width; this is what old redisplay code
2013 pcm
= x_per_char_metric (font
, &char2b
);
2014 if (font_not_found_p
|| !pcm
)
2016 int charset
= CHAR_CHARSET (it
->char_to_display
);
2018 it
->glyph_not_available_p
= 1;
2019 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
2020 * CHARSET_WIDTH (charset
));
2021 it
->phys_ascent
= font
->ascent
+ boff
;
2022 it
->phys_descent
= font
->descent
- boff
;
2026 it
->pixel_width
= pcm
->width
;
2027 it
->phys_ascent
= pcm
->ascent
+ boff
;
2028 it
->phys_descent
= pcm
->descent
- boff
;
2030 && (pcm
->lbearing
< 0
2031 || pcm
->rbearing
> pcm
->width
))
2032 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2035 it
->ascent
= font
->ascent
+ boff
;
2036 it
->descent
= font
->descent
- boff
;
2037 if (face
->box
!= FACE_NO_BOX
)
2039 int thick
= face
->box_line_width
;
2043 it
->ascent
+= thick
;
2044 it
->descent
+= thick
;
2049 if (it
->start_of_box_run_p
)
2050 it
->pixel_width
+= thick
;
2051 if (it
->end_of_box_run_p
)
2052 it
->pixel_width
+= thick
;
2055 /* If face has an overline, add the height of the overline
2056 (1 pixel) and a 1 pixel margin to the character height. */
2057 if (face
->overline_p
)
2060 take_vertical_position_into_account (it
);
2063 x_append_glyph (it
);
2065 it
->multibyte_p
= saved_multibyte_p
;
2067 else if (it
->what
== IT_COMPOSITION
)
2069 /* Note: A composition is represented as one glyph in the
2070 glyph matrix. There are no padding glyphs. */
2073 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2075 int font_not_found_p
;
2076 struct font_info
*font_info
;
2077 int boff
; /* baseline offset */
2078 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2080 /* Maybe translate single-byte characters to multibyte. */
2081 it
->char_to_display
= it
->c
;
2082 if (unibyte_display_via_language_environment
2083 && SINGLE_BYTE_CHAR_P (it
->c
)
2086 && !NILP (Vnonascii_translation_table
))))
2088 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2091 /* Get face and font to use. Encode IT->char_to_display. */
2092 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2093 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2094 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2095 it
->face_id
, &char2b
, it
->multibyte_p
, 0);
2098 /* When no suitable font found, use the default font. */
2099 font_not_found_p
= font
== NULL
;
2100 if (font_not_found_p
)
2102 font
= FRAME_FONT (it
->f
);
2103 boff
= it
->f
->output_data
.x
->baseline_offset
;
2108 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2109 boff
= font_info
->baseline_offset
;
2110 if (font_info
->vertical_centering
)
2111 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2114 /* There are no padding glyphs, so there is only one glyph to
2115 produce for the composition. Important is that pixel_width,
2116 ascent and descent are the values of what is drawn by
2117 draw_glyphs (i.e. the values of the overall glyphs composed). */
2120 /* If we have not yet calculated pixel size data of glyphs of
2121 the composition for the current face font, calculate them
2122 now. Theoretically, we have to check all fonts for the
2123 glyphs, but that requires much time and memory space. So,
2124 here we check only the font of the first glyph. This leads
2125 to incorrect display very rarely, and C-l (recenter) can
2126 correct the display anyway. */
2127 if (cmp
->font
!= (void *) font
)
2129 /* Ascent and descent of the font of the first character of
2130 this composition (adjusted by baseline offset). Ascent
2131 and descent of overall glyphs should not be less than
2132 them respectively. */
2133 int font_ascent
= font
->ascent
+ boff
;
2134 int font_descent
= font
->descent
- boff
;
2135 /* Bounding box of the overall glyphs. */
2136 int leftmost
, rightmost
, lowest
, highest
;
2137 int i
, width
, ascent
, descent
;
2139 cmp
->font
= (void *) font
;
2141 /* Initialize the bounding box. */
2143 && (pcm
= x_per_char_metric (font
, &char2b
)))
2146 ascent
= pcm
->ascent
;
2147 descent
= pcm
->descent
;
2151 width
= FONT_WIDTH (font
);
2152 ascent
= font
->ascent
;
2153 descent
= font
->descent
;
2157 lowest
= - descent
+ boff
;
2158 highest
= ascent
+ boff
;
2162 && font_info
->default_ascent
2163 && CHAR_TABLE_P (Vuse_default_ascent
)
2164 && !NILP (Faref (Vuse_default_ascent
,
2165 make_number (it
->char_to_display
))))
2166 highest
= font_info
->default_ascent
+ boff
;
2168 /* Draw the first glyph at the normal position. It may be
2169 shifted to right later if some other glyphs are drawn at
2171 cmp
->offsets
[0] = 0;
2172 cmp
->offsets
[1] = boff
;
2174 /* Set cmp->offsets for the remaining glyphs. */
2175 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2177 int left
, right
, btm
, top
;
2178 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2179 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2181 face
= FACE_FROM_ID (it
->f
, face_id
);
2182 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2183 it
->multibyte_p
, 0);
2187 font
= FRAME_FONT (it
->f
);
2188 boff
= it
->f
->output_data
.x
->baseline_offset
;
2194 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2195 boff
= font_info
->baseline_offset
;
2196 if (font_info
->vertical_centering
)
2197 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2201 && (pcm
= x_per_char_metric (font
, &char2b
)))
2204 ascent
= pcm
->ascent
;
2205 descent
= pcm
->descent
;
2209 width
= FONT_WIDTH (font
);
2214 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2216 /* Relative composition with or without
2218 left
= (leftmost
+ rightmost
- width
) / 2;
2219 btm
= - descent
+ boff
;
2220 if (font_info
&& font_info
->relative_compose
2221 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2222 || NILP (Faref (Vignore_relative_composition
,
2223 make_number (ch
)))))
2226 if (- descent
>= font_info
->relative_compose
)
2227 /* One extra pixel between two glyphs. */
2229 else if (ascent
<= 0)
2230 /* One extra pixel between two glyphs. */
2231 btm
= lowest
- 1 - ascent
- descent
;
2236 /* A composition rule is specified by an integer
2237 value that encodes global and new reference
2238 points (GREF and NREF). GREF and NREF are
2239 specified by numbers as below:
2247 ---3---4---5--- baseline
2249 6---7---8 -- descent
2251 int rule
= COMPOSITION_RULE (cmp
, i
);
2252 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2254 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2255 grefx
= gref
% 3, nrefx
= nref
% 3;
2256 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2259 + grefx
* (rightmost
- leftmost
) / 2
2260 - nrefx
* width
/ 2);
2261 btm
= ((grefy
== 0 ? highest
2263 : grefy
== 2 ? lowest
2264 : (highest
+ lowest
) / 2)
2265 - (nrefy
== 0 ? ascent
+ descent
2266 : nrefy
== 1 ? descent
- boff
2268 : (ascent
+ descent
) / 2));
2271 cmp
->offsets
[i
* 2] = left
;
2272 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2274 /* Update the bounding box of the overall glyphs. */
2275 right
= left
+ width
;
2276 top
= btm
+ descent
+ ascent
;
2277 if (left
< leftmost
)
2279 if (right
> rightmost
)
2287 /* If there are glyphs whose x-offsets are negative,
2288 shift all glyphs to the right and make all x-offsets
2292 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2293 cmp
->offsets
[i
* 2] -= leftmost
;
2294 rightmost
-= leftmost
;
2297 cmp
->pixel_width
= rightmost
;
2298 cmp
->ascent
= highest
;
2299 cmp
->descent
= - lowest
;
2300 if (cmp
->ascent
< font_ascent
)
2301 cmp
->ascent
= font_ascent
;
2302 if (cmp
->descent
< font_descent
)
2303 cmp
->descent
= font_descent
;
2306 it
->pixel_width
= cmp
->pixel_width
;
2307 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2308 it
->descent
= it
->phys_descent
= cmp
->descent
;
2310 if (face
->box
!= FACE_NO_BOX
)
2312 int thick
= face
->box_line_width
;
2316 it
->ascent
+= thick
;
2317 it
->descent
+= thick
;
2322 if (it
->start_of_box_run_p
)
2323 it
->pixel_width
+= thick
;
2324 if (it
->end_of_box_run_p
)
2325 it
->pixel_width
+= thick
;
2328 /* If face has an overline, add the height of the overline
2329 (1 pixel) and a 1 pixel margin to the character height. */
2330 if (face
->overline_p
)
2333 take_vertical_position_into_account (it
);
2336 x_append_composite_glyph (it
);
2338 else if (it
->what
== IT_IMAGE
)
2339 x_produce_image_glyph (it
);
2340 else if (it
->what
== IT_STRETCH
)
2341 x_produce_stretch_glyph (it
);
2343 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2344 because this isn't true for images with `:ascent 100'. */
2345 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2346 if (it
->area
== TEXT_AREA
)
2347 it
->current_x
+= it
->pixel_width
;
2349 it
->descent
+= it
->extra_line_spacing
;
2351 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2352 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2353 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2354 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2358 /* Estimate the pixel height of the mode or top line on frame F.
2359 FACE_ID specifies what line's height to estimate. */
2362 x_estimate_mode_line_height (f
, face_id
)
2364 enum face_id face_id
;
2366 int height
= FONT_HEIGHT (FRAME_FONT (f
));
2368 /* This function is called so early when Emacs starts that the face
2369 cache and mode line face are not yet initialized. */
2370 if (FRAME_FACE_CACHE (f
))
2372 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2376 height
= FONT_HEIGHT (face
->font
);
2377 if (face
->box_line_width
> 0)
2378 height
+= 2 * face
->box_line_width
;
2386 /***********************************************************************
2388 ***********************************************************************/
2390 /* A sequence of glyphs to be drawn in the same face.
2392 This data structure is not really completely X specific, so it
2393 could possibly, at least partially, be useful for other systems. It
2394 is currently not part of the external redisplay interface because
2395 it's not clear what other systems will need. */
2399 /* X-origin of the string. */
2402 /* Y-origin and y-position of the base line of this string. */
2405 /* The width of the string, not including a face extension. */
2408 /* The width of the string, including a face extension. */
2409 int background_width
;
2411 /* The height of this string. This is the height of the line this
2412 string is drawn in, and can be different from the height of the
2413 font the string is drawn in. */
2416 /* Number of pixels this string overwrites in front of its x-origin.
2417 This number is zero if the string has an lbearing >= 0; it is
2418 -lbearing, if the string has an lbearing < 0. */
2421 /* Number of pixels this string overwrites past its right-most
2422 nominal x-position, i.e. x + width. Zero if the string's
2423 rbearing is <= its nominal width, rbearing - width otherwise. */
2426 /* The frame on which the glyph string is drawn. */
2429 /* The window on which the glyph string is drawn. */
2432 /* X display and window for convenience. */
2436 /* The glyph row for which this string was built. It determines the
2437 y-origin and height of the string. */
2438 struct glyph_row
*row
;
2440 /* The area within row. */
2441 enum glyph_row_area area
;
2443 /* Characters to be drawn, and number of characters. */
2447 /* A face-override for drawing cursors, mouse face and similar. */
2448 enum draw_glyphs_face hl
;
2450 /* Face in which this string is to be drawn. */
2453 /* Font in which this string is to be drawn. */
2456 /* Font info for this string. */
2457 struct font_info
*font_info
;
2459 /* Non-null means this string describes (part of) a composition.
2460 All characters from char2b are drawn composed. */
2461 struct composition
*cmp
;
2463 /* Index of this glyph string's first character in the glyph
2464 definition of CMP. If this is zero, this glyph string describes
2465 the first character of a composition. */
2468 /* 1 means this glyph strings face has to be drawn to the right end
2469 of the window's drawing area. */
2470 unsigned extends_to_end_of_line_p
: 1;
2472 /* 1 means the background of this string has been drawn. */
2473 unsigned background_filled_p
: 1;
2475 /* 1 means glyph string must be drawn with 16-bit functions. */
2476 unsigned two_byte_p
: 1;
2478 /* 1 means that the original font determined for drawing this glyph
2479 string could not be loaded. The member `font' has been set to
2480 the frame's default font in this case. */
2481 unsigned font_not_found_p
: 1;
2483 /* 1 means that the face in which this glyph string is drawn has a
2485 unsigned stippled_p
: 1;
2487 /* 1 means only the foreground of this glyph string must be drawn,
2488 and we should use the physical height of the line this glyph
2489 string appears in as clip rect. */
2490 unsigned for_overlaps_p
: 1;
2492 /* The GC to use for drawing this glyph string. */
2495 /* A pointer to the first glyph in the string. This glyph
2496 corresponds to char2b[0]. Needed to draw rectangles if
2497 font_not_found_p is 1. */
2498 struct glyph
*first_glyph
;
2500 /* Image, if any. */
2503 struct glyph_string
*next
, *prev
;
2510 x_dump_glyph_string (s
)
2511 struct glyph_string
*s
;
2513 fprintf (stderr
, "glyph string\n");
2514 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2515 s
->x
, s
->y
, s
->width
, s
->height
);
2516 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2517 fprintf (stderr
, " hl = %d\n", s
->hl
);
2518 fprintf (stderr
, " left overhang = %d, right = %d\n",
2519 s
->left_overhang
, s
->right_overhang
);
2520 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2521 fprintf (stderr
, " extends to end of line = %d\n",
2522 s
->extends_to_end_of_line_p
);
2523 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2524 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2527 #endif /* GLYPH_DEBUG */
2531 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2532 struct glyph_string
**,
2533 struct glyph_string
*,
2534 struct glyph_string
*));
2535 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2536 struct glyph_string
**,
2537 struct glyph_string
*,
2538 struct glyph_string
*));
2539 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2540 struct glyph_string
**,
2541 struct glyph_string
*));
2542 static int x_left_overwritten
P_ ((struct glyph_string
*));
2543 static int x_left_overwriting
P_ ((struct glyph_string
*));
2544 static int x_right_overwritten
P_ ((struct glyph_string
*));
2545 static int x_right_overwriting
P_ ((struct glyph_string
*));
2546 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2548 static void x_init_glyph_string
P_ ((struct glyph_string
*,
2549 XChar2b
*, struct window
*,
2551 enum glyph_row_area
, int,
2552 enum draw_glyphs_face
));
2553 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2554 enum glyph_row_area
, int, int,
2555 enum draw_glyphs_face
, int));
2556 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2557 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2558 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2560 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2561 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2562 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2563 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2564 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2565 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2566 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2567 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2568 static void x_get_glyph_overhangs
P_ ((struct glyph
*, struct frame
*,
2570 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2571 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
2572 unsigned long *, double, int));
2573 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2574 double, int, unsigned long));
2575 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2576 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2577 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2578 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2579 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
2580 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2581 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2583 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2584 int, int, int, int, XRectangle
*));
2585 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2586 int, int, int, XRectangle
*));
2587 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2588 enum glyph_row_area
));
2589 static int x_fill_stretch_glyph_string
P_ ((struct glyph_string
*,
2591 enum glyph_row_area
, int, int));
2594 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2598 /* Append the list of glyph strings with head H and tail T to the list
2599 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2602 x_append_glyph_string_lists (head
, tail
, h
, t
)
2603 struct glyph_string
**head
, **tail
;
2604 struct glyph_string
*h
, *t
;
2618 /* Prepend the list of glyph strings with head H and tail T to the
2619 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2623 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2624 struct glyph_string
**head
, **tail
;
2625 struct glyph_string
*h
, *t
;
2639 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2640 Set *HEAD and *TAIL to the resulting list. */
2643 x_append_glyph_string (head
, tail
, s
)
2644 struct glyph_string
**head
, **tail
;
2645 struct glyph_string
*s
;
2647 s
->next
= s
->prev
= NULL
;
2648 x_append_glyph_string_lists (head
, tail
, s
, s
);
2652 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2657 struct glyph_string
*s
;
2659 if (s
->font
== FRAME_FONT (s
->f
)
2660 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2661 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2663 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
2666 /* Cursor on non-default face: must merge. */
2670 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
2671 xgcv
.foreground
= s
->face
->background
;
2673 /* If the glyph would be invisible, try a different foreground. */
2674 if (xgcv
.foreground
== xgcv
.background
)
2675 xgcv
.foreground
= s
->face
->foreground
;
2676 if (xgcv
.foreground
== xgcv
.background
)
2677 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
2678 if (xgcv
.foreground
== xgcv
.background
)
2679 xgcv
.foreground
= s
->face
->foreground
;
2681 /* Make sure the cursor is distinct from text in this face. */
2682 if (xgcv
.background
== s
->face
->background
2683 && xgcv
.foreground
== s
->face
->foreground
)
2685 xgcv
.background
= s
->face
->foreground
;
2686 xgcv
.foreground
= s
->face
->background
;
2689 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2690 xgcv
.font
= s
->font
->fid
;
2691 xgcv
.graphics_exposures
= False
;
2692 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2694 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2695 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2698 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2699 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2701 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2706 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2709 x_set_mouse_face_gc (s
)
2710 struct glyph_string
*s
;
2715 /* What face has to be used last for the mouse face? */
2716 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2717 face
= FACE_FROM_ID (s
->f
, face_id
);
2719 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
2721 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2722 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2724 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2725 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2726 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2728 /* If font in this face is same as S->font, use it. */
2729 if (s
->font
== s
->face
->font
)
2730 s
->gc
= s
->face
->gc
;
2733 /* Otherwise construct scratch_cursor_gc with values from FACE
2738 xgcv
.background
= s
->face
->background
;
2739 xgcv
.foreground
= s
->face
->foreground
;
2740 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2741 xgcv
.font
= s
->font
->fid
;
2742 xgcv
.graphics_exposures
= False
;
2743 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2745 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2746 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2749 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2750 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2752 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2755 xassert (s
->gc
!= 0);
2759 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2760 Faces to use in the mode line have already been computed when the
2761 matrix was built, so there isn't much to do, here. */
2764 x_set_mode_line_face_gc (s
)
2765 struct glyph_string
*s
;
2767 s
->gc
= s
->face
->gc
;
2771 /* Set S->gc of glyph string S for drawing that glyph string. Set
2772 S->stippled_p to a non-zero value if the face of S has a stipple
2776 x_set_glyph_string_gc (s
)
2777 struct glyph_string
*s
;
2779 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2781 if (s
->hl
== DRAW_NORMAL_TEXT
)
2783 s
->gc
= s
->face
->gc
;
2784 s
->stippled_p
= s
->face
->stipple
!= 0;
2786 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2788 x_set_mode_line_face_gc (s
);
2789 s
->stippled_p
= s
->face
->stipple
!= 0;
2791 else if (s
->hl
== DRAW_CURSOR
)
2793 x_set_cursor_gc (s
);
2796 else if (s
->hl
== DRAW_MOUSE_FACE
)
2798 x_set_mouse_face_gc (s
);
2799 s
->stippled_p
= s
->face
->stipple
!= 0;
2801 else if (s
->hl
== DRAW_IMAGE_RAISED
2802 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2804 s
->gc
= s
->face
->gc
;
2805 s
->stippled_p
= s
->face
->stipple
!= 0;
2809 s
->gc
= s
->face
->gc
;
2810 s
->stippled_p
= s
->face
->stipple
!= 0;
2813 /* GC must have been set. */
2814 xassert (s
->gc
!= 0);
2818 /* Return in *R the clipping rectangle for glyph string S. */
2821 x_get_glyph_string_clip_rect (s
, r
)
2822 struct glyph_string
*s
;
2825 if (s
->row
->full_width_p
)
2827 /* Draw full-width. X coordinates are relative to S->w->left. */
2828 int canon_x
= CANON_X_UNIT (s
->f
);
2830 r
->x
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
2831 r
->width
= XFASTINT (s
->w
->width
) * canon_x
;
2833 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
2835 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
2836 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
2840 r
->x
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
2842 /* Unless displaying a mode or menu bar line, which are always
2843 fully visible, clip to the visible part of the row. */
2844 if (s
->w
->pseudo_window_p
)
2845 r
->height
= s
->row
->visible_height
;
2847 r
->height
= s
->height
;
2851 /* This is a text line that may be partially visible. */
2852 r
->x
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
2853 r
->width
= window_box_width (s
->w
, s
->area
);
2854 r
->height
= s
->row
->visible_height
;
2857 /* If S draws overlapping rows, it's sufficient to use the top and
2858 bottom of the window for clipping because this glyph string
2859 intentionally draws over other lines. */
2860 if (s
->for_overlaps_p
)
2862 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2863 r
->height
= window_text_bottom_y (s
->w
) - r
->y
;
2867 /* Don't use S->y for clipping because it doesn't take partially
2868 visible lines into account. For example, it can be negative for
2869 partially visible lines at the top of a window. */
2870 if (!s
->row
->full_width_p
2871 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2872 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2874 r
->y
= max (0, s
->row
->y
);
2876 /* If drawing a tool-bar window, draw it over the internal border
2877 at the top of the window. */
2878 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
2879 r
->y
-= s
->f
->output_data
.x
->internal_border_width
;
2882 r
->y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->y
);
2886 /* Set clipping for output of glyph string S. S may be part of a mode
2887 line or menu if we don't have X toolkit support. */
2890 x_set_glyph_string_clipping (s
)
2891 struct glyph_string
*s
;
2894 x_get_glyph_string_clip_rect (s
, &r
);
2895 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
2899 /* Compute left and right overhang of glyph string S. If S is a glyph
2900 string for a composition, assume overhangs don't exist. */
2903 x_compute_glyph_string_overhangs (s
)
2904 struct glyph_string
*s
;
2907 && s
->first_glyph
->type
== CHAR_GLYPH
)
2910 int direction
, font_ascent
, font_descent
;
2911 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
2912 &font_ascent
, &font_descent
, &cs
);
2913 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2914 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2919 /* Compute overhangs and x-positions for glyph string S and its
2920 predecessors, or successors. X is the starting x-position for S.
2921 BACKWARD_P non-zero means process predecessors. */
2924 x_compute_overhangs_and_x (s
, x
, backward_p
)
2925 struct glyph_string
*s
;
2933 x_compute_glyph_string_overhangs (s
);
2943 x_compute_glyph_string_overhangs (s
);
2952 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2953 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2954 assumed to be zero. */
2957 x_get_glyph_overhangs (glyph
, f
, left
, right
)
2958 struct glyph
*glyph
;
2964 if (glyph
->type
== CHAR_GLYPH
)
2968 struct font_info
*font_info
;
2972 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
2974 font_info
= FONT_INFO_FROM_ID (f
, face
->font_info_id
);
2976 && (pcm
= x_per_char_metric (font
, &char2b
)))
2978 if (pcm
->rbearing
> pcm
->width
)
2979 *right
= pcm
->rbearing
- pcm
->width
;
2980 if (pcm
->lbearing
< 0)
2981 *left
= -pcm
->lbearing
;
2987 /* Return the index of the first glyph preceding glyph string S that
2988 is overwritten by S because of S's left overhang. Value is -1
2989 if no glyphs are overwritten. */
2992 x_left_overwritten (s
)
2993 struct glyph_string
*s
;
2997 if (s
->left_overhang
)
3000 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3001 int first
= s
->first_glyph
- glyphs
;
3003 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
3004 x
-= glyphs
[i
].pixel_width
;
3015 /* Return the index of the first glyph preceding glyph string S that
3016 is overwriting S because of its right overhang. Value is -1 if no
3017 glyph in front of S overwrites S. */
3020 x_left_overwriting (s
)
3021 struct glyph_string
*s
;
3024 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3025 int first
= s
->first_glyph
- glyphs
;
3029 for (i
= first
- 1; i
>= 0; --i
)
3032 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3035 x
-= glyphs
[i
].pixel_width
;
3042 /* Return the index of the last glyph following glyph string S that is
3043 not overwritten by S because of S's right overhang. Value is -1 if
3044 no such glyph is found. */
3047 x_right_overwritten (s
)
3048 struct glyph_string
*s
;
3052 if (s
->right_overhang
)
3055 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3056 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3057 int end
= s
->row
->used
[s
->area
];
3059 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3060 x
+= glyphs
[i
].pixel_width
;
3069 /* Return the index of the last glyph following glyph string S that
3070 overwrites S because of its left overhang. Value is negative
3071 if no such glyph is found. */
3074 x_right_overwriting (s
)
3075 struct glyph_string
*s
;
3078 int end
= s
->row
->used
[s
->area
];
3079 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3080 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3084 for (i
= first
; i
< end
; ++i
)
3087 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3090 x
+= glyphs
[i
].pixel_width
;
3097 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3100 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3101 struct glyph_string
*s
;
3105 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
3106 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3107 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3108 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3112 /* Draw the background of glyph_string S. If S->background_filled_p
3113 is non-zero don't draw it. FORCE_P non-zero means draw the
3114 background even if it wouldn't be drawn normally. This is used
3115 when a string preceding S draws into the background of S, or S
3116 contains the first component of a composition. */
3119 x_draw_glyph_string_background (s
, force_p
)
3120 struct glyph_string
*s
;
3123 /* Nothing to do if background has already been drawn or if it
3124 shouldn't be drawn in the first place. */
3125 if (!s
->background_filled_p
)
3127 int box_line_width
= max (s
->face
->box_line_width
, 0);
3131 /* Fill background with a stipple pattern. */
3132 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3133 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3134 s
->y
+ box_line_width
,
3135 s
->background_width
,
3136 s
->height
- 2 * box_line_width
);
3137 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3138 s
->background_filled_p
= 1;
3140 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
3141 || s
->font_not_found_p
3142 || s
->extends_to_end_of_line_p
3145 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
3146 s
->background_width
,
3147 s
->height
- 2 * box_line_width
);
3148 s
->background_filled_p
= 1;
3154 /* Draw the foreground of glyph string S. */
3157 x_draw_glyph_string_foreground (s
)
3158 struct glyph_string
*s
;
3162 /* If first glyph of S has a left box line, start drawing the text
3163 of S to the right of that box line. */
3164 if (s
->face
->box
!= FACE_NO_BOX
3165 && s
->first_glyph
->left_box_line_p
)
3166 x
= s
->x
+ abs (s
->face
->box_line_width
);
3170 /* Draw characters of S as rectangles if S's font could not be
3172 if (s
->font_not_found_p
)
3174 for (i
= 0; i
< s
->nchars
; ++i
)
3176 struct glyph
*g
= s
->first_glyph
+ i
;
3177 XDrawRectangle (s
->display
, s
->window
,
3178 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3180 x
+= g
->pixel_width
;
3185 char *char1b
= (char *) s
->char2b
;
3186 int boff
= s
->font_info
->baseline_offset
;
3188 if (s
->font_info
->vertical_centering
)
3189 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3191 /* If we can use 8-bit functions, condense S->char2b. */
3193 for (i
= 0; i
< s
->nchars
; ++i
)
3194 char1b
[i
] = s
->char2b
[i
].byte2
;
3196 /* Draw text with XDrawString if background has already been
3197 filled. Otherwise, use XDrawImageString. (Note that
3198 XDrawImageString is usually faster than XDrawString.) Always
3199 use XDrawImageString when drawing the cursor so that there is
3200 no chance that characters under a box cursor are invisible. */
3201 if (s
->for_overlaps_p
3202 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3204 /* Draw characters with 16-bit or 8-bit functions. */
3206 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
3207 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3209 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
3210 s
->ybase
- boff
, char1b
, s
->nchars
);
3215 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
3216 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3218 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
3219 s
->ybase
- boff
, char1b
, s
->nchars
);
3224 /* Draw the foreground of composite glyph string S. */
3227 x_draw_composite_glyph_string_foreground (s
)
3228 struct glyph_string
*s
;
3232 /* If first glyph of S has a left box line, start drawing the text
3233 of S to the right of that box line. */
3234 if (s
->face
->box
!= FACE_NO_BOX
3235 && s
->first_glyph
->left_box_line_p
)
3236 x
= s
->x
+ abs (s
->face
->box_line_width
);
3240 /* S is a glyph string for a composition. S->gidx is the index of
3241 the first character drawn for glyphs of this composition.
3242 S->gidx == 0 means we are drawing the very first character of
3243 this composition. */
3245 /* Draw a rectangle for the composition if the font for the very
3246 first character of the composition could not be loaded. */
3247 if (s
->font_not_found_p
)
3250 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
3251 s
->width
- 1, s
->height
- 1);
3255 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3256 XDrawString16 (s
->display
, s
->window
, s
->gc
,
3257 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3258 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3264 #ifdef USE_X_TOOLKIT
3266 static struct frame
*x_frame_of_widget
P_ ((Widget
));
3267 static Boolean cvt_string_to_pixel
P_ ((Display
*, XrmValue
*, Cardinal
*,
3268 XrmValue
*, XrmValue
*, XtPointer
*));
3269 static void cvt_pixel_dtor
P_ ((XtAppContext
, XrmValue
*, XtPointer
,
3270 XrmValue
*, Cardinal
*));
3273 /* Return the frame on which widget WIDGET is used.. Abort if frame
3274 cannot be determined. */
3276 static struct frame
*
3277 x_frame_of_widget (widget
)
3280 struct x_display_info
*dpyinfo
;
3284 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3286 /* Find the top-level shell of the widget. Note that this function
3287 can be called when the widget is not yet realized, so XtWindow
3288 (widget) == 0. That's the reason we can't simply use
3289 x_any_window_to_frame. */
3290 while (!XtIsTopLevelShell (widget
))
3291 widget
= XtParent (widget
);
3293 /* Look for a frame with that top-level widget. Allocate the color
3294 on that frame to get the right gamma correction value. */
3295 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3296 if (GC_FRAMEP (XCAR (tail
))
3297 && (f
= XFRAME (XCAR (tail
)),
3298 (f
->output_data
.nothing
!= 1
3299 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3300 && f
->output_data
.x
->widget
== widget
)
3307 /* Allocate the color COLOR->pixel on the screen and display of
3308 widget WIDGET in colormap CMAP. If an exact match cannot be
3309 allocated, try the nearest color available. Value is non-zero
3310 if successful. This is called from lwlib. */
3313 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3318 struct frame
*f
= x_frame_of_widget (widget
);
3319 return x_alloc_nearest_color (f
, cmap
, color
);
3323 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3324 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3325 If this produces the same color as PIXEL, try a color where all RGB
3326 values have DELTA added. Return the allocated color in *PIXEL.
3327 DISPLAY is the X display, CMAP is the colormap to operate on.
3328 Value is non-zero if successful. */
3331 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
3335 unsigned long *pixel
;
3339 struct frame
*f
= x_frame_of_widget (widget
);
3340 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
3344 /* Structure specifying which arguments should be passed by Xt to
3345 cvt_string_to_pixel. We want the widget's screen and colormap. */
3347 static XtConvertArgRec cvt_string_to_pixel_args
[] =
3349 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
3351 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
3356 /* The address of this variable is returned by
3357 cvt_string_to_pixel. */
3359 static Pixel cvt_string_to_pixel_value
;
3362 /* Convert a color name to a pixel color.
3364 DPY is the display we are working on.
3366 ARGS is an array of *NARGS XrmValue structures holding additional
3367 information about the widget for which the conversion takes place.
3368 The contents of this array are determined by the specification
3369 in cvt_string_to_pixel_args.
3371 FROM is a pointer to an XrmValue which points to the color name to
3372 convert. TO is an XrmValue in which to return the pixel color.
3374 CLOSURE_RET is a pointer to user-data, in which we record if
3375 we allocated the color or not.
3377 Value is True if successful, False otherwise. */
3380 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
3384 XrmValue
*from
, *to
;
3385 XtPointer
*closure_ret
;
3395 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
3396 "wrongParameters", "cvt_string_to_pixel",
3398 "Screen and colormap args required", NULL
, NULL
);
3402 screen
= *(Screen
**) args
[0].addr
;
3403 cmap
= *(Colormap
*) args
[1].addr
;
3404 color_name
= (String
) from
->addr
;
3406 if (strcmp (color_name
, XtDefaultBackground
) == 0)
3408 *closure_ret
= (XtPointer
) False
;
3409 pixel
= WhitePixelOfScreen (screen
);
3411 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
3413 *closure_ret
= (XtPointer
) False
;
3414 pixel
= BlackPixelOfScreen (screen
);
3416 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
3417 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
3419 pixel
= color
.pixel
;
3420 *closure_ret
= (XtPointer
) True
;
3425 Cardinal nparams
= 1;
3427 params
[0] = color_name
;
3428 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
3429 "badValue", "cvt_string_to_pixel",
3430 "XtToolkitError", "Invalid color `%s'",
3435 if (to
->addr
!= NULL
)
3437 if (to
->size
< sizeof (Pixel
))
3439 to
->size
= sizeof (Pixel
);
3443 *(Pixel
*) to
->addr
= pixel
;
3447 cvt_string_to_pixel_value
= pixel
;
3448 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
3451 to
->size
= sizeof (Pixel
);
3456 /* Free a pixel color which was previously allocated via
3457 cvt_string_to_pixel. This is registered as the destructor
3458 for this type of resource via XtSetTypeConverter.
3460 APP is the application context in which we work.
3462 TO is a pointer to an XrmValue holding the color to free.
3463 CLOSURE is the value we stored in CLOSURE_RET for this color
3464 in cvt_string_to_pixel.
3466 ARGS and NARGS are like for cvt_string_to_pixel. */
3469 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
3478 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
3480 "Screen and colormap arguments required",
3483 else if (closure
!= NULL
)
3485 /* We did allocate the pixel, so free it. */
3486 Screen
*screen
= *(Screen
**) args
[0].addr
;
3487 Colormap cmap
= *(Colormap
*) args
[1].addr
;
3488 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
3489 (Pixel
*) to
->addr
, 1);
3494 #endif /* USE_X_TOOLKIT */
3497 /* Value is an array of XColor structures for the contents of the
3498 color map of display DPY. Set *NCELLS to the size of the array.
3499 Note that this probably shouldn't be called for large color maps,
3500 say a 24-bit TrueColor map. */
3502 static const XColor
*
3503 x_color_cells (dpy
, ncells
)
3507 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
3509 if (dpyinfo
->color_cells
== NULL
)
3511 Screen
*screen
= dpyinfo
->screen
;
3514 dpyinfo
->ncolor_cells
3515 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
3516 dpyinfo
->color_cells
3517 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
3518 * sizeof *dpyinfo
->color_cells
);
3520 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
3521 dpyinfo
->color_cells
[i
].pixel
= i
;
3523 XQueryColors (dpy
, dpyinfo
->cmap
,
3524 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
3527 *ncells
= dpyinfo
->ncolor_cells
;
3528 return dpyinfo
->color_cells
;
3532 /* On frame F, translate pixel colors to RGB values for the NCOLORS
3533 colors in COLORS. Use cached information, if available. */
3536 x_query_colors (f
, colors
, ncolors
)
3541 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3543 if (dpyinfo
->color_cells
)
3546 for (i
= 0; i
< ncolors
; ++i
)
3548 unsigned long pixel
= colors
[i
].pixel
;
3549 xassert (pixel
< dpyinfo
->ncolor_cells
);
3550 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
3551 colors
[i
] = dpyinfo
->color_cells
[pixel
];
3555 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
3559 /* On frame F, translate pixel color to RGB values for the color in
3560 COLOR. Use cached information, if available. */
3563 x_query_color (f
, color
)
3567 x_query_colors (f
, color
, 1);
3571 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
3572 exact match can't be allocated, try the nearest color available.
3573 Value is non-zero if successful. Set *COLOR to the color
3577 x_alloc_nearest_color_1 (dpy
, cmap
, color
)
3584 rc
= XAllocColor (dpy
, cmap
, color
);
3587 /* If we got to this point, the colormap is full, so we're going
3588 to try to get the next closest color. The algorithm used is
3589 a least-squares matching, which is what X uses for closest
3590 color matching with StaticColor visuals. */
3592 unsigned long nearest_delta
= ~0;
3594 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
3596 for (nearest
= i
= 0; i
< ncells
; ++i
)
3598 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3599 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3600 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3601 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3603 if (delta
< nearest_delta
)
3606 nearest_delta
= delta
;
3610 color
->red
= cells
[nearest
].red
;
3611 color
->green
= cells
[nearest
].green
;
3612 color
->blue
= cells
[nearest
].blue
;
3613 rc
= XAllocColor (dpy
, cmap
, color
);
3617 /* If allocation succeeded, and the allocated pixel color is not
3618 equal to a cached pixel color recorded earlier, there was a
3619 change in the colormap, so clear the color cache. */
3620 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
3621 XColor
*cached_color
;
3623 if (dpyinfo
->color_cells
3624 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
3625 (cached_color
->red
!= color
->red
3626 || cached_color
->blue
!= color
->blue
3627 || cached_color
->green
!= color
->green
)))
3629 xfree (dpyinfo
->color_cells
);
3630 dpyinfo
->color_cells
= NULL
;
3631 dpyinfo
->ncolor_cells
= 0;
3635 #ifdef DEBUG_X_COLORS
3637 register_color (color
->pixel
);
3638 #endif /* DEBUG_X_COLORS */
3644 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
3645 exact match can't be allocated, try the nearest color available.
3646 Value is non-zero if successful. Set *COLOR to the color
3650 x_alloc_nearest_color (f
, cmap
, color
)
3655 gamma_correct (f
, color
);
3656 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
3660 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3661 It's necessary to do this instead of just using PIXEL directly to
3662 get color reference counts right. */
3665 x_copy_color (f
, pixel
)
3667 unsigned long pixel
;
3671 color
.pixel
= pixel
;
3673 x_query_color (f
, &color
);
3674 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3676 #ifdef DEBUG_X_COLORS
3677 register_color (pixel
);
3683 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3684 It's necessary to do this instead of just using PIXEL directly to
3685 get color reference counts right. */
3688 x_copy_dpy_color (dpy
, cmap
, pixel
)
3691 unsigned long pixel
;
3695 color
.pixel
= pixel
;
3697 XQueryColor (dpy
, cmap
, &color
);
3698 XAllocColor (dpy
, cmap
, &color
);
3700 #ifdef DEBUG_X_COLORS
3701 register_color (pixel
);
3707 /* Brightness beyond which a color won't have its highlight brightness
3710 Nominally, highlight colors for `3d' faces are calculated by
3711 brightening an object's color by a constant scale factor, but this
3712 doesn't yield good results for dark colors, so for colors who's
3713 brightness is less than this value (on a scale of 0-65535) have an
3714 use an additional additive factor.
3716 The value here is set so that the default menu-bar/mode-line color
3717 (grey75) will not have its highlights changed at all. */
3718 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
3721 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3722 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3723 If this produces the same color as PIXEL, try a color where all RGB
3724 values have DELTA added. Return the allocated color in *PIXEL.
3725 DISPLAY is the X display, CMAP is the colormap to operate on.
3726 Value is non-zero if successful. */
3729 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
3733 unsigned long *pixel
;
3741 /* Get RGB color values. */
3742 color
.pixel
= *pixel
;
3743 x_query_color (f
, &color
);
3745 /* Change RGB values by specified FACTOR. Avoid overflow! */
3746 xassert (factor
>= 0);
3747 new.red
= min (0xffff, factor
* color
.red
);
3748 new.green
= min (0xffff, factor
* color
.green
);
3749 new.blue
= min (0xffff, factor
* color
.blue
);
3751 /* Calculate brightness of COLOR. */
3752 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
3754 /* We only boost colors that are darker than
3755 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3756 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3757 /* Make an additive adjustment to NEW, because it's dark enough so
3758 that scaling by FACTOR alone isn't enough. */
3760 /* How far below the limit this color is (0 - 1, 1 being darker). */
3761 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3762 /* The additive adjustment. */
3763 int min_delta
= delta
* dimness
* factor
/ 2;
3767 new.red
= max (0, new.red
- min_delta
);
3768 new.green
= max (0, new.green
- min_delta
);
3769 new.blue
= max (0, new.blue
- min_delta
);
3773 new.red
= min (0xffff, min_delta
+ new.red
);
3774 new.green
= min (0xffff, min_delta
+ new.green
);
3775 new.blue
= min (0xffff, min_delta
+ new.blue
);
3779 /* Try to allocate the color. */
3780 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3783 if (new.pixel
== *pixel
)
3785 /* If we end up with the same color as before, try adding
3786 delta to the RGB values. */
3787 x_free_colors (f
, &new.pixel
, 1);
3789 new.red
= min (0xffff, delta
+ color
.red
);
3790 new.green
= min (0xffff, delta
+ color
.green
);
3791 new.blue
= min (0xffff, delta
+ color
.blue
);
3792 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3803 /* Set up the foreground color for drawing relief lines of glyph
3804 string S. RELIEF is a pointer to a struct relief containing the GC
3805 with which lines will be drawn. Use a color that is FACTOR or
3806 DELTA lighter or darker than the relief's background which is found
3807 in S->f->output_data.x->relief_background. If such a color cannot
3808 be allocated, use DEFAULT_PIXEL, instead. */
3811 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3813 struct relief
*relief
;
3816 unsigned long default_pixel
;
3819 struct x_output
*di
= f
->output_data
.x
;
3820 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
3821 unsigned long pixel
;
3822 unsigned long background
= di
->relief_background
;
3823 Colormap cmap
= FRAME_X_COLORMAP (f
);
3824 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3825 Display
*dpy
= FRAME_X_DISPLAY (f
);
3827 xgcv
.graphics_exposures
= False
;
3828 xgcv
.line_width
= 1;
3830 /* Free previously allocated color. The color cell will be reused
3831 when it has been freed as many times as it was allocated, so this
3832 doesn't affect faces using the same colors. */
3834 && relief
->allocated_p
)
3836 x_free_colors (f
, &relief
->pixel
, 1);
3837 relief
->allocated_p
= 0;
3840 /* Allocate new color. */
3841 xgcv
.foreground
= default_pixel
;
3843 if (dpyinfo
->n_planes
!= 1
3844 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
3846 relief
->allocated_p
= 1;
3847 xgcv
.foreground
= relief
->pixel
= pixel
;
3850 if (relief
->gc
== 0)
3852 xgcv
.stipple
= dpyinfo
->gray
;
3854 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
3857 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
3861 /* Set up colors for the relief lines around glyph string S. */
3864 x_setup_relief_colors (s
)
3865 struct glyph_string
*s
;
3867 struct x_output
*di
= s
->f
->output_data
.x
;
3868 unsigned long color
;
3870 if (s
->face
->use_box_color_for_shadows_p
)
3871 color
= s
->face
->box_color
;
3872 else if (s
->first_glyph
->type
== IMAGE_GLYPH
3874 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
3875 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
3880 /* Get the background color of the face. */
3881 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3882 color
= xgcv
.background
;
3885 if (di
->white_relief
.gc
== 0
3886 || color
!= di
->relief_background
)
3888 di
->relief_background
= color
;
3889 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3890 WHITE_PIX_DEFAULT (s
->f
));
3891 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3892 BLACK_PIX_DEFAULT (s
->f
));
3897 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3898 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3899 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3900 relief. LEFT_P non-zero means draw a relief on the left side of
3901 the rectangle. RIGHT_P non-zero means draw a relief on the right
3902 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3906 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3907 raised_p
, left_p
, right_p
, clip_rect
)
3909 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3910 XRectangle
*clip_rect
;
3912 Display
*dpy
= FRAME_X_DISPLAY (f
);
3913 Window window
= FRAME_X_WINDOW (f
);
3918 gc
= f
->output_data
.x
->white_relief
.gc
;
3920 gc
= f
->output_data
.x
->black_relief
.gc
;
3921 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
3924 for (i
= 0; i
< width
; ++i
)
3925 XDrawLine (dpy
, window
, gc
,
3926 left_x
+ i
* left_p
, top_y
+ i
,
3927 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3931 for (i
= 0; i
< width
; ++i
)
3932 XDrawLine (dpy
, window
, gc
,
3933 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
3935 XSetClipMask (dpy
, gc
, None
);
3937 gc
= f
->output_data
.x
->black_relief
.gc
;
3939 gc
= f
->output_data
.x
->white_relief
.gc
;
3940 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
3943 for (i
= 0; i
< width
; ++i
)
3944 XDrawLine (dpy
, window
, gc
,
3945 left_x
+ i
* left_p
, bottom_y
- i
,
3946 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3950 for (i
= 0; i
< width
; ++i
)
3951 XDrawLine (dpy
, window
, gc
,
3952 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3954 XSetClipMask (dpy
, gc
, None
);
3958 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3959 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3960 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3961 left side of the rectangle. RIGHT_P non-zero means draw a line
3962 on the right side of the rectangle. CLIP_RECT is the clipping
3963 rectangle to use when drawing. */
3966 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3967 left_p
, right_p
, clip_rect
)
3968 struct glyph_string
*s
;
3969 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
;
3970 XRectangle
*clip_rect
;
3974 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3975 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3976 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
3979 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3980 left_x
, top_y
, right_x
- left_x
+ 1, width
);
3984 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3985 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
3988 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3989 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
3993 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3994 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
3996 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3997 XSetClipMask (s
->display
, s
->gc
, None
);
4001 /* Draw a box around glyph string S. */
4004 x_draw_glyph_string_box (s
)
4005 struct glyph_string
*s
;
4007 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
4008 int left_p
, right_p
;
4009 struct glyph
*last_glyph
;
4010 XRectangle clip_rect
;
4012 last_x
= window_box_right (s
->w
, s
->area
);
4013 if (s
->row
->full_width_p
4014 && !s
->w
->pseudo_window_p
)
4016 last_x
+= FRAME_X_RIGHT_FRINGE_WIDTH (s
->f
);
4017 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
4018 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
4021 /* The glyph that may have a right box line. */
4022 last_glyph
= (s
->cmp
|| s
->img
4024 : s
->first_glyph
+ s
->nchars
- 1);
4026 width
= abs (s
->face
->box_line_width
);
4027 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
4029 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
4031 : min (last_x
, s
->x
+ s
->background_width
) - 1);
4033 bottom_y
= top_y
+ s
->height
- 1;
4035 left_p
= (s
->first_glyph
->left_box_line_p
4036 || (s
->hl
== DRAW_MOUSE_FACE
4038 || s
->prev
->hl
!= s
->hl
)));
4039 right_p
= (last_glyph
->right_box_line_p
4040 || (s
->hl
== DRAW_MOUSE_FACE
4042 || s
->next
->hl
!= s
->hl
)));
4044 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4046 if (s
->face
->box
== FACE_SIMPLE_BOX
)
4047 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
4048 left_p
, right_p
, &clip_rect
);
4051 x_setup_relief_colors (s
);
4052 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
4053 width
, raised_p
, left_p
, right_p
, &clip_rect
);
4058 /* Draw foreground of image glyph string S. */
4061 x_draw_image_foreground (s
)
4062 struct glyph_string
*s
;
4065 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
4067 /* If first glyph of S has a left box line, start drawing it to the
4068 right of that line. */
4069 if (s
->face
->box
!= FACE_NO_BOX
4070 && s
->first_glyph
->left_box_line_p
)
4071 x
= s
->x
+ abs (s
->face
->box_line_width
);
4075 /* If there is a margin around the image, adjust x- and y-position
4077 x
+= s
->img
->hmargin
;
4078 y
+= s
->img
->vmargin
;
4084 /* We can't set both a clip mask and use XSetClipRectangles
4085 because the latter also sets a clip mask. We also can't
4086 trust on the shape extension to be available
4087 (XShapeCombineRegion). So, compute the rectangle to draw
4089 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4092 XRectangle clip_rect
, image_rect
, r
;
4094 xgcv
.clip_mask
= s
->img
->mask
;
4095 xgcv
.clip_x_origin
= x
;
4096 xgcv
.clip_y_origin
= y
;
4097 xgcv
.function
= GXcopy
;
4098 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4100 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4103 image_rect
.width
= s
->img
->width
;
4104 image_rect
.height
= s
->img
->height
;
4105 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
4106 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
4107 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
4111 XRectangle clip_rect
, image_rect
, r
;
4113 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4116 image_rect
.width
= s
->img
->width
;
4117 image_rect
.height
= s
->img
->height
;
4118 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
4119 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
4120 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
4122 /* When the image has a mask, we can expect that at
4123 least part of a mouse highlight or a block cursor will
4124 be visible. If the image doesn't have a mask, make
4125 a block cursor visible by drawing a rectangle around
4126 the image. I believe it's looking better if we do
4127 nothing here for mouse-face. */
4128 if (s
->hl
== DRAW_CURSOR
)
4130 int r
= s
->img
->relief
;
4132 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
4133 s
->img
->width
+ r
*2 - 1, s
->img
->height
+ r
*2 - 1);
4138 /* Draw a rectangle if image could not be loaded. */
4139 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
4140 s
->img
->width
- 1, s
->img
->height
- 1);
4144 /* Draw a relief around the image glyph string S. */
4147 x_draw_image_relief (s
)
4148 struct glyph_string
*s
;
4150 int x0
, y0
, x1
, y1
, thick
, raised_p
;
4153 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
4155 /* If first glyph of S has a left box line, start drawing it to the
4156 right of that line. */
4157 if (s
->face
->box
!= FACE_NO_BOX
4158 && s
->first_glyph
->left_box_line_p
)
4159 x
= s
->x
+ abs (s
->face
->box_line_width
);
4163 /* If there is a margin around the image, adjust x- and y-position
4165 x
+= s
->img
->hmargin
;
4166 y
+= s
->img
->vmargin
;
4168 if (s
->hl
== DRAW_IMAGE_SUNKEN
4169 || s
->hl
== DRAW_IMAGE_RAISED
)
4171 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
4172 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
4176 thick
= abs (s
->img
->relief
);
4177 raised_p
= s
->img
->relief
> 0;
4182 x1
= x
+ s
->img
->width
+ thick
- 1;
4183 y1
= y
+ s
->img
->height
+ thick
- 1;
4185 x_setup_relief_colors (s
);
4186 x_get_glyph_string_clip_rect (s
, &r
);
4187 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
4191 /* Draw the foreground of image glyph string S to PIXMAP. */
4194 x_draw_image_foreground_1 (s
, pixmap
)
4195 struct glyph_string
*s
;
4199 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
4201 /* If first glyph of S has a left box line, start drawing it to the
4202 right of that line. */
4203 if (s
->face
->box
!= FACE_NO_BOX
4204 && s
->first_glyph
->left_box_line_p
)
4205 x
= abs (s
->face
->box_line_width
);
4209 /* If there is a margin around the image, adjust x- and y-position
4211 x
+= s
->img
->hmargin
;
4212 y
+= s
->img
->vmargin
;
4218 /* We can't set both a clip mask and use XSetClipRectangles
4219 because the latter also sets a clip mask. We also can't
4220 trust on the shape extension to be available
4221 (XShapeCombineRegion). So, compute the rectangle to draw
4223 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4227 xgcv
.clip_mask
= s
->img
->mask
;
4228 xgcv
.clip_x_origin
= x
;
4229 xgcv
.clip_y_origin
= y
;
4230 xgcv
.function
= GXcopy
;
4231 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4233 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4234 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4235 XSetClipMask (s
->display
, s
->gc
, None
);
4239 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4240 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4242 /* When the image has a mask, we can expect that at
4243 least part of a mouse highlight or a block cursor will
4244 be visible. If the image doesn't have a mask, make
4245 a block cursor visible by drawing a rectangle around
4246 the image. I believe it's looking better if we do
4247 nothing here for mouse-face. */
4248 if (s
->hl
== DRAW_CURSOR
)
4250 int r
= s
->img
->relief
;
4252 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
4253 s
->img
->width
+ r
*2 - 1, s
->img
->height
+ r
*2 - 1);
4258 /* Draw a rectangle if image could not be loaded. */
4259 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
4260 s
->img
->width
- 1, s
->img
->height
- 1);
4264 /* Draw part of the background of glyph string S. X, Y, W, and H
4265 give the rectangle to draw. */
4268 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4269 struct glyph_string
*s
;
4274 /* Fill background with a stipple pattern. */
4275 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4276 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4277 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4280 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4284 /* Draw image glyph string S.
4287 s->x +-------------------------
4290 | +-------------------------
4293 | | +-------------------
4299 x_draw_image_glyph_string (s
)
4300 struct glyph_string
*s
;
4303 int box_line_hwidth
= abs (s
->face
->box_line_width
);
4304 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
4306 Pixmap pixmap
= None
;
4308 height
= s
->height
- 2 * box_line_vwidth
;
4310 /* Fill background with face under the image. Do it only if row is
4311 taller than image or if image has a clip mask to reduce
4313 s
->stippled_p
= s
->face
->stipple
!= 0;
4314 if (height
> s
->img
->height
4318 || s
->img
->pixmap
== 0
4319 || s
->width
!= s
->background_width
)
4321 if (box_line_hwidth
&& s
->first_glyph
->left_box_line_p
)
4322 x
= s
->x
+ box_line_hwidth
;
4326 y
= s
->y
+ box_line_vwidth
;
4330 /* Create a pixmap as large as the glyph string. Fill it
4331 with the background color. Copy the image to it, using
4332 its mask. Copy the temporary pixmap to the display. */
4333 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4334 int depth
= DefaultDepthOfScreen (screen
);
4336 /* Create a pixmap as large as the glyph string. */
4337 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4338 s
->background_width
,
4341 /* Don't clip in the following because we're working on the
4343 XSetClipMask (s
->display
, s
->gc
, None
);
4345 /* Fill the pixmap with the background color/stipple. */
4348 /* Fill background with a stipple pattern. */
4349 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4350 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4351 0, 0, s
->background_width
, s
->height
);
4352 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4357 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4359 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4360 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4361 0, 0, s
->background_width
, s
->height
);
4362 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4366 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4368 s
->background_filled_p
= 1;
4371 /* Draw the foreground. */
4374 x_draw_image_foreground_1 (s
, pixmap
);
4375 x_set_glyph_string_clipping (s
);
4376 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
4377 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
4378 XFreePixmap (s
->display
, pixmap
);
4381 x_draw_image_foreground (s
);
4383 /* If we must draw a relief around the image, do it. */
4385 || s
->hl
== DRAW_IMAGE_RAISED
4386 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4387 x_draw_image_relief (s
);
4391 /* Draw stretch glyph string S. */
4394 x_draw_stretch_glyph_string (s
)
4395 struct glyph_string
*s
;
4397 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4398 s
->stippled_p
= s
->face
->stipple
!= 0;
4400 if (s
->hl
== DRAW_CURSOR
4401 && !x_stretch_cursor_p
)
4403 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4404 as wide as the stretch glyph. */
4405 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4408 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4410 /* Clear rest using the GC of the original non-cursor face. */
4411 if (width
< s
->background_width
)
4413 int x
= s
->x
+ width
, y
= s
->y
;
4414 int w
= s
->background_width
- width
, h
= s
->height
;
4418 if (s
->row
->mouse_face_p
4419 && cursor_in_mouse_face_p (s
->w
))
4421 x_set_mouse_face_gc (s
);
4427 x_get_glyph_string_clip_rect (s
, &r
);
4428 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
4430 if (s
->face
->stipple
)
4432 /* Fill background with a stipple pattern. */
4433 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4434 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4435 XSetFillStyle (s
->display
, gc
, FillSolid
);
4440 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
4441 XSetForeground (s
->display
, gc
, xgcv
.background
);
4442 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4443 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
4447 else if (!s
->background_filled_p
)
4448 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4451 s
->background_filled_p
= 1;
4455 /* Draw glyph string S. */
4458 x_draw_glyph_string (s
)
4459 struct glyph_string
*s
;
4461 int relief_drawn_p
= 0;
4463 /* If S draws into the background of its successor, draw the
4464 background of the successor first so that S can draw into it.
4465 This makes S->next use XDrawString instead of XDrawImageString. */
4466 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4468 xassert (s
->next
->img
== NULL
);
4469 x_set_glyph_string_gc (s
->next
);
4470 x_set_glyph_string_clipping (s
->next
);
4471 x_draw_glyph_string_background (s
->next
, 1);
4474 /* Set up S->gc, set clipping and draw S. */
4475 x_set_glyph_string_gc (s
);
4477 /* Draw relief (if any) in advance for char/composition so that the
4478 glyph string can be drawn over it. */
4479 if (!s
->for_overlaps_p
4480 && s
->face
->box
!= FACE_NO_BOX
4481 && (s
->first_glyph
->type
== CHAR_GLYPH
4482 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
4485 x_set_glyph_string_clipping (s
);
4486 x_draw_glyph_string_background (s
, 1);
4487 x_draw_glyph_string_box (s
);
4488 x_set_glyph_string_clipping (s
);
4492 x_set_glyph_string_clipping (s
);
4494 switch (s
->first_glyph
->type
)
4497 x_draw_image_glyph_string (s
);
4501 x_draw_stretch_glyph_string (s
);
4505 if (s
->for_overlaps_p
)
4506 s
->background_filled_p
= 1;
4508 x_draw_glyph_string_background (s
, 0);
4509 x_draw_glyph_string_foreground (s
);
4512 case COMPOSITE_GLYPH
:
4513 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4514 s
->background_filled_p
= 1;
4516 x_draw_glyph_string_background (s
, 1);
4517 x_draw_composite_glyph_string_foreground (s
);
4524 if (!s
->for_overlaps_p
)
4526 /* Draw underline. */
4527 if (s
->face
->underline_p
)
4529 unsigned long tem
, h
;
4532 /* Get the underline thickness. Default is 1 pixel. */
4533 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
4536 /* Get the underline position. This is the recommended
4537 vertical offset in pixels from the baseline to the top of
4538 the underline. This is a signed value according to the
4539 specs, and its default is
4541 ROUND ((maximum descent) / 2), with
4542 ROUND(x) = floor (x + 0.5) */
4544 if (x_use_underline_position_properties
4545 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
4546 y
= s
->ybase
+ (long) tem
;
4547 else if (s
->face
->font
)
4548 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
4550 y
= s
->y
+ s
->height
- h
;
4552 if (s
->face
->underline_defaulted_p
)
4553 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4554 s
->x
, y
, s
->width
, h
);
4558 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4559 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
4560 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4561 s
->x
, y
, s
->width
, h
);
4562 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4566 /* Draw overline. */
4567 if (s
->face
->overline_p
)
4569 unsigned long dy
= 0, h
= 1;
4571 if (s
->face
->overline_color_defaulted_p
)
4572 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4577 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4578 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4579 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4581 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4585 /* Draw strike-through. */
4586 if (s
->face
->strike_through_p
)
4588 unsigned long h
= 1;
4589 unsigned long dy
= (s
->height
- h
) / 2;
4591 if (s
->face
->strike_through_color_defaulted_p
)
4592 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4597 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4598 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4599 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4601 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4605 /* Draw relief if not yet drawn. */
4606 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
4607 x_draw_glyph_string_box (s
);
4610 /* Reset clipping. */
4611 XSetClipMask (s
->display
, s
->gc
, None
);
4615 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4616 struct face
**, int));
4619 /* Fill glyph string S with composition components specified by S->cmp.
4621 FACES is an array of faces for all components of this composition.
4622 S->gidx is the index of the first component for S.
4623 OVERLAPS_P non-zero means S should draw the foreground only, and
4624 use its physical height for clipping.
4626 Value is the index of a component not in S. */
4629 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4630 struct glyph_string
*s
;
4631 struct face
**faces
;
4638 s
->for_overlaps_p
= overlaps_p
;
4640 s
->face
= faces
[s
->gidx
];
4641 s
->font
= s
->face
->font
;
4642 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4644 /* For all glyphs of this composition, starting at the offset
4645 S->gidx, until we reach the end of the definition or encounter a
4646 glyph that requires the different face, add it to S. */
4648 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4651 /* All glyph strings for the same composition has the same width,
4652 i.e. the width set for the first component of the composition. */
4654 s
->width
= s
->first_glyph
->pixel_width
;
4656 /* If the specified font could not be loaded, use the frame's
4657 default font, but record the fact that we couldn't load it in
4658 the glyph string so that we can draw rectangles for the
4659 characters of the glyph string. */
4660 if (s
->font
== NULL
)
4662 s
->font_not_found_p
= 1;
4663 s
->font
= FRAME_FONT (s
->f
);
4666 /* Adjust base line for subscript/superscript text. */
4667 s
->ybase
+= s
->first_glyph
->voffset
;
4669 xassert (s
->face
&& s
->face
->gc
);
4671 /* This glyph string must always be drawn with 16-bit functions. */
4674 return s
->gidx
+ s
->nchars
;
4678 /* Fill glyph string S from a sequence of character glyphs.
4680 FACE_ID is the face id of the string. START is the index of the
4681 first glyph to consider, END is the index of the last + 1.
4682 OVERLAPS_P non-zero means S should draw the foreground only, and
4683 use its physical height for clipping.
4685 Value is the index of the first glyph not in S. */
4688 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4689 struct glyph_string
*s
;
4691 int start
, end
, overlaps_p
;
4693 struct glyph
*glyph
, *last
;
4695 int glyph_not_available_p
;
4697 xassert (s
->f
== XFRAME (s
->w
->frame
));
4698 xassert (s
->nchars
== 0);
4699 xassert (start
>= 0 && end
> start
);
4701 s
->for_overlaps_p
= overlaps_p
,
4702 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4703 last
= s
->row
->glyphs
[s
->area
] + end
;
4704 voffset
= glyph
->voffset
;
4706 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4709 && glyph
->type
== CHAR_GLYPH
4710 && glyph
->voffset
== voffset
4711 /* Same face id implies same font, nowadays. */
4712 && glyph
->face_id
== face_id
4713 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4717 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4718 s
->char2b
+ s
->nchars
,
4720 s
->two_byte_p
= two_byte_p
;
4722 xassert (s
->nchars
<= end
- start
);
4723 s
->width
+= glyph
->pixel_width
;
4727 s
->font
= s
->face
->font
;
4728 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4730 /* If the specified font could not be loaded, use the frame's font,
4731 but record the fact that we couldn't load it in
4732 S->font_not_found_p so that we can draw rectangles for the
4733 characters of the glyph string. */
4734 if (s
->font
== NULL
|| glyph_not_available_p
)
4736 s
->font_not_found_p
= 1;
4737 s
->font
= FRAME_FONT (s
->f
);
4740 /* Adjust base line for subscript/superscript text. */
4741 s
->ybase
+= voffset
;
4743 xassert (s
->face
&& s
->face
->gc
);
4744 return glyph
- s
->row
->glyphs
[s
->area
];
4748 /* Fill glyph string S from image glyph S->first_glyph. */
4751 x_fill_image_glyph_string (s
)
4752 struct glyph_string
*s
;
4754 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4755 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4757 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4758 s
->font
= s
->face
->font
;
4759 s
->width
= s
->first_glyph
->pixel_width
;
4761 /* Adjust base line for subscript/superscript text. */
4762 s
->ybase
+= s
->first_glyph
->voffset
;
4766 /* Fill glyph string S from a sequence of stretch glyphs.
4768 ROW is the glyph row in which the glyphs are found, AREA is the
4769 area within the row. START is the index of the first glyph to
4770 consider, END is the index of the last + 1.
4772 Value is the index of the first glyph not in S. */
4775 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4776 struct glyph_string
*s
;
4777 struct glyph_row
*row
;
4778 enum glyph_row_area area
;
4781 struct glyph
*glyph
, *last
;
4782 int voffset
, face_id
;
4784 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4786 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4787 last
= s
->row
->glyphs
[s
->area
] + end
;
4788 face_id
= glyph
->face_id
;
4789 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4790 s
->font
= s
->face
->font
;
4791 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4792 s
->width
= glyph
->pixel_width
;
4793 voffset
= glyph
->voffset
;
4797 && glyph
->type
== STRETCH_GLYPH
4798 && glyph
->voffset
== voffset
4799 && glyph
->face_id
== face_id
);
4801 s
->width
+= glyph
->pixel_width
;
4803 /* Adjust base line for subscript/superscript text. */
4804 s
->ybase
+= voffset
;
4806 /* The case that face->gc == 0 is handled when drawing the glyph
4807 string by calling PREPARE_FACE_FOR_DISPLAY. */
4809 return glyph
- s
->row
->glyphs
[s
->area
];
4813 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4814 of XChar2b structures for S; it can't be allocated in
4815 x_init_glyph_string because it must be allocated via `alloca'. W
4816 is the window on which S is drawn. ROW and AREA are the glyph row
4817 and area within the row from which S is constructed. START is the
4818 index of the first glyph structure covered by S. HL is a
4819 face-override for drawing S. */
4822 x_init_glyph_string (s
, char2b
, w
, row
, area
, start
, hl
)
4823 struct glyph_string
*s
;
4826 struct glyph_row
*row
;
4827 enum glyph_row_area area
;
4829 enum draw_glyphs_face hl
;
4831 bzero (s
, sizeof *s
);
4833 s
->f
= XFRAME (w
->frame
);
4834 s
->display
= FRAME_X_DISPLAY (s
->f
);
4835 s
->window
= FRAME_X_WINDOW (s
->f
);
4840 s
->first_glyph
= row
->glyphs
[area
] + start
;
4841 s
->height
= row
->height
;
4842 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4844 /* Display the internal border below the tool-bar window. */
4845 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4846 s
->y
-= s
->f
->output_data
.x
->internal_border_width
;
4848 s
->ybase
= s
->y
+ row
->ascent
;
4852 /* Set background width of glyph string S. START is the index of the
4853 first glyph following S. LAST_X is the right-most x-position + 1
4854 in the drawing area. */
4857 x_set_glyph_string_background_width (s
, start
, last_x
)
4858 struct glyph_string
*s
;
4862 /* If the face of this glyph string has to be drawn to the end of
4863 the drawing area, set S->extends_to_end_of_line_p. */
4864 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4866 if (start
== s
->row
->used
[s
->area
]
4867 && s
->area
== TEXT_AREA
4868 && ((s
->hl
== DRAW_NORMAL_TEXT
4869 && (s
->row
->fill_line_p
4870 || s
->face
->background
!= default_face
->background
4871 || s
->face
->stipple
!= default_face
->stipple
4872 || s
->row
->mouse_face_p
))
4873 || s
->hl
== DRAW_MOUSE_FACE
4874 || ((s
->hl
== DRAW_IMAGE_RAISED
|| s
->hl
== DRAW_IMAGE_SUNKEN
)
4875 && s
->row
->fill_line_p
)))
4876 s
->extends_to_end_of_line_p
= 1;
4878 /* If S extends its face to the end of the line, set its
4879 background_width to the distance to the right edge of the drawing
4881 if (s
->extends_to_end_of_line_p
)
4882 s
->background_width
= last_x
- s
->x
+ 1;
4884 s
->background_width
= s
->width
;
4888 /* Add a glyph string for a stretch glyph to the list of strings
4889 between HEAD and TAIL. START is the index of the stretch glyph in
4890 row area AREA of glyph row ROW. END is the index of the last glyph
4891 in that glyph row area. X is the current output position assigned
4892 to the new glyph string constructed. HL overrides that face of the
4893 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4894 is the right-most x-position of the drawing area. */
4896 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4897 and below -- keep them on one line. */
4898 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4901 s = (struct glyph_string *) alloca (sizeof *s); \
4902 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4903 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4904 x_append_glyph_string (&HEAD, &TAIL, s); \
4910 /* Add a glyph string for an image glyph to the list of strings
4911 between HEAD and TAIL. START is the index of the image glyph in
4912 row area AREA of glyph row ROW. END is the index of the last glyph
4913 in that glyph row area. X is the current output position assigned
4914 to the new glyph string constructed. HL overrides that face of the
4915 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4916 is the right-most x-position of the drawing area. */
4918 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4921 s = (struct glyph_string *) alloca (sizeof *s); \
4922 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4923 x_fill_image_glyph_string (s); \
4924 x_append_glyph_string (&HEAD, &TAIL, s); \
4931 /* Add a glyph string for a sequence of character glyphs to the list
4932 of strings between HEAD and TAIL. START is the index of the first
4933 glyph in row area AREA of glyph row ROW that is part of the new
4934 glyph string. END is the index of the last glyph in that glyph row
4935 area. X is the current output position assigned to the new glyph
4936 string constructed. HL overrides that face of the glyph; e.g. it
4937 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4938 right-most x-position of the drawing area. */
4940 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4946 c = (ROW)->glyphs[AREA][START].u.ch; \
4947 face_id = (ROW)->glyphs[AREA][START].face_id; \
4949 s = (struct glyph_string *) alloca (sizeof *s); \
4950 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4951 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4952 x_append_glyph_string (&HEAD, &TAIL, s); \
4954 START = x_fill_glyph_string (s, face_id, START, END, \
4960 /* Add a glyph string for a composite sequence to the list of strings
4961 between HEAD and TAIL. START is the index of the first glyph in
4962 row area AREA of glyph row ROW that is part of the new glyph
4963 string. END is the index of the last glyph in that glyph row area.
4964 X is the current output position assigned to the new glyph string
4965 constructed. HL overrides that face of the glyph; e.g. it is
4966 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4967 x-position of the drawing area. */
4969 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4971 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4972 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4973 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4974 struct composition *cmp = composition_table[cmp_id]; \
4975 int glyph_len = cmp->glyph_len; \
4977 struct face **faces; \
4978 struct glyph_string *first_s = NULL; \
4981 base_face = base_face->ascii_face; \
4982 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4983 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4984 /* At first, fill in `char2b' and `faces'. */ \
4985 for (n = 0; n < glyph_len; n++) \
4987 int c = COMPOSITION_GLYPH (cmp, n); \
4988 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4989 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4990 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4991 this_face_id, char2b + n, 1, 1); \
4994 /* Make glyph_strings for each glyph sequence that is drawable by \
4995 the same face, and append them to HEAD/TAIL. */ \
4996 for (n = 0; n < cmp->glyph_len;) \
4998 s = (struct glyph_string *) alloca (sizeof *s); \
4999 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
5000 x_append_glyph_string (&(HEAD), &(TAIL), s); \
5008 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
5016 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
5017 of AREA of glyph row ROW on window W between indices START and END.
5018 HL overrides the face for drawing glyph strings, e.g. it is
5019 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
5020 x-positions of the drawing area.
5022 This is an ugly monster macro construct because we must use alloca
5023 to allocate glyph strings (because x_draw_glyphs can be called
5026 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
5029 HEAD = TAIL = NULL; \
5030 while (START < END) \
5032 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
5033 switch (first_glyph->type) \
5036 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
5037 TAIL, HL, X, LAST_X, \
5041 case COMPOSITE_GLYPH: \
5042 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
5043 HEAD, TAIL, HL, X, LAST_X,\
5047 case STRETCH_GLYPH: \
5048 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
5049 HEAD, TAIL, HL, X, LAST_X); \
5053 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
5054 TAIL, HL, X, LAST_X); \
5061 x_set_glyph_string_background_width (s, START, LAST_X); \
5068 /* Draw glyphs between START and END in AREA of ROW on window W,
5069 starting at x-position X. X is relative to AREA in W. HL is a
5070 face-override with the following meaning:
5072 DRAW_NORMAL_TEXT draw normally
5073 DRAW_CURSOR draw in cursor face
5074 DRAW_MOUSE_FACE draw in mouse face.
5075 DRAW_INVERSE_VIDEO draw in mode line face
5076 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
5077 DRAW_IMAGE_RAISED draw an image with a raised relief around it
5079 If OVERLAPS_P is non-zero, draw only the foreground of characters
5080 and clip to the physical height of ROW.
5082 Value is the x-position reached, relative to AREA of W. */
5085 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, overlaps_p
)
5088 struct glyph_row
*row
;
5089 enum glyph_row_area area
;
5091 enum draw_glyphs_face hl
;
5094 struct glyph_string
*head
, *tail
;
5095 struct glyph_string
*s
;
5096 int last_x
, area_width
;
5100 /* Let's rather be paranoid than getting a SEGV. */
5101 end
= min (end
, row
->used
[area
]);
5102 start
= max (0, start
);
5103 start
= min (end
, start
);
5105 /* Translate X to frame coordinates. Set last_x to the right
5106 end of the drawing area. */
5107 if (row
->full_width_p
)
5109 /* X is relative to the left edge of W, without scroll bars
5111 struct frame
*f
= XFRAME (w
->frame
);
5112 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
5115 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5116 last_x
= window_left_x
+ area_width
;
5118 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5120 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5121 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
5127 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
5128 last_x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
5132 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
5133 area_width
= window_box_width (w
, area
);
5134 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
5137 /* Build a doubly-linked list of glyph_string structures between
5138 head and tail from what we have to draw. Note that the macro
5139 BUILD_GLYPH_STRINGS will modify its start parameter. That's
5140 the reason we use a separate variable `i'. */
5142 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
5145 x_reached
= tail
->x
+ tail
->background_width
;
5149 /* If there are any glyphs with lbearing < 0 or rbearing > width in
5150 the row, redraw some glyphs in front or following the glyph
5151 strings built above. */
5152 if (head
&& !overlaps_p
&& row
->contains_overlapping_glyphs_p
)
5155 struct glyph_string
*h
, *t
;
5157 /* Compute overhangs for all glyph strings. */
5158 for (s
= head
; s
; s
= s
->next
)
5159 x_compute_glyph_string_overhangs (s
);
5161 /* Prepend glyph strings for glyphs in front of the first glyph
5162 string that are overwritten because of the first glyph
5163 string's left overhang. The background of all strings
5164 prepended must be drawn because the first glyph string
5166 i
= x_left_overwritten (head
);
5170 BUILD_GLYPH_STRINGS (w
, row
, area
, j
, start
, h
, t
,
5171 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5174 x_compute_overhangs_and_x (t
, head
->x
, 1);
5175 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5178 /* Prepend glyph strings for glyphs in front of the first glyph
5179 string that overwrite that glyph string because of their
5180 right overhang. For these strings, only the foreground must
5181 be drawn, because it draws over the glyph string at `head'.
5182 The background must not be drawn because this would overwrite
5183 right overhangs of preceding glyphs for which no glyph
5185 i
= x_left_overwriting (head
);
5188 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, start
, h
, t
,
5189 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5191 for (s
= h
; s
; s
= s
->next
)
5192 s
->background_filled_p
= 1;
5193 x_compute_overhangs_and_x (t
, head
->x
, 1);
5194 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5197 /* Append glyphs strings for glyphs following the last glyph
5198 string tail that are overwritten by tail. The background of
5199 these strings has to be drawn because tail's foreground draws
5201 i
= x_right_overwritten (tail
);
5204 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5205 DRAW_NORMAL_TEXT
, x
, last_x
,
5207 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5208 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5211 /* Append glyph strings for glyphs following the last glyph
5212 string tail that overwrite tail. The foreground of such
5213 glyphs has to be drawn because it writes into the background
5214 of tail. The background must not be drawn because it could
5215 paint over the foreground of following glyphs. */
5216 i
= x_right_overwriting (tail
);
5219 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5220 DRAW_NORMAL_TEXT
, x
, last_x
,
5222 for (s
= h
; s
; s
= s
->next
)
5223 s
->background_filled_p
= 1;
5224 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5225 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5229 /* Draw all strings. */
5230 for (s
= head
; s
; s
= s
->next
)
5231 x_draw_glyph_string (s
);
5233 if (area
== TEXT_AREA
5234 && !row
->full_width_p
5235 /* When drawing overlapping rows, only the glyph strings'
5236 foreground is drawn, which doesn't erase a cursor
5240 int x0
= head
? head
->x
: x
;
5241 int x1
= tail
? tail
->x
+ tail
->background_width
: x
;
5243 x0
= FRAME_TO_WINDOW_PIXEL_X (w
, x0
);
5244 x1
= FRAME_TO_WINDOW_PIXEL_X (w
, x1
);
5246 if (XFASTINT (w
->left_margin_width
) != 0)
5248 int left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
5249 x0
-= left_area_width
;
5250 x1
-= left_area_width
;
5253 notice_overwritten_cursor (w
, area
, x0
, x1
,
5254 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
5257 /* Value is the x-position up to which drawn, relative to AREA of W.
5258 This doesn't include parts drawn because of overhangs. */
5259 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
5260 if (!row
->full_width_p
)
5262 if (area
> LEFT_MARGIN_AREA
&& XFASTINT (w
->left_margin_width
) != 0)
5263 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5264 if (area
> TEXT_AREA
)
5265 x_reached
-= window_box_width (w
, TEXT_AREA
);
5272 /* Fix the display of area AREA of overlapping row ROW in window W. */
5275 x_fix_overlapping_area (w
, row
, area
)
5277 struct glyph_row
*row
;
5278 enum glyph_row_area area
;
5284 if (area
== LEFT_MARGIN_AREA
)
5286 else if (area
== TEXT_AREA
)
5287 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5289 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5290 + window_box_width (w
, TEXT_AREA
));
5292 for (i
= 0; i
< row
->used
[area
];)
5294 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
5296 int start
= i
, start_x
= x
;
5300 x
+= row
->glyphs
[area
][i
].pixel_width
;
5303 while (i
< row
->used
[area
]
5304 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5306 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5307 DRAW_NORMAL_TEXT
, 1);
5311 x
+= row
->glyphs
[area
][i
].pixel_width
;
5320 /* Output LEN glyphs starting at START at the nominal cursor position.
5321 Advance the nominal cursor over the text. The global variable
5322 updated_window contains the window being updated, updated_row is
5323 the glyph row being updated, and updated_area is the area of that
5324 row being updated. */
5327 x_write_glyphs (start
, len
)
5328 struct glyph
*start
;
5333 xassert (updated_window
&& updated_row
);
5338 hpos
= start
- updated_row
->glyphs
[updated_area
];
5339 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5340 updated_row
, updated_area
,
5342 DRAW_NORMAL_TEXT
, 0);
5344 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
5345 if (updated_area
== TEXT_AREA
5346 && updated_window
->phys_cursor_on_p
5347 && updated_window
->phys_cursor
.vpos
== output_cursor
.vpos
5348 && updated_window
->phys_cursor
.hpos
>= hpos
5349 && updated_window
->phys_cursor
.hpos
< hpos
+ len
)
5350 updated_window
->phys_cursor_on_p
= 0;
5354 /* Advance the output cursor. */
5355 output_cursor
.hpos
+= len
;
5356 output_cursor
.x
= x
;
5360 /* Insert LEN glyphs from START at the nominal cursor position. */
5363 x_insert_glyphs (start
, len
)
5364 struct glyph
*start
;
5369 int line_height
, shift_by_width
, shifted_region_width
;
5370 struct glyph_row
*row
;
5371 struct glyph
*glyph
;
5372 int frame_x
, frame_y
, hpos
;
5374 xassert (updated_window
&& updated_row
);
5377 f
= XFRAME (WINDOW_FRAME (w
));
5379 /* Get the height of the line we are in. */
5381 line_height
= row
->height
;
5383 /* Get the width of the glyphs to insert. */
5385 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5386 shift_by_width
+= glyph
->pixel_width
;
5388 /* Get the width of the region to shift right. */
5389 shifted_region_width
= (window_box_width (w
, updated_area
)
5394 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
5395 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5396 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5397 f
->output_data
.x
->normal_gc
,
5399 shifted_region_width
, line_height
,
5400 frame_x
+ shift_by_width
, frame_y
);
5402 /* Write the glyphs. */
5403 hpos
= start
- row
->glyphs
[updated_area
];
5404 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5405 DRAW_NORMAL_TEXT
, 0);
5407 /* Advance the output cursor. */
5408 output_cursor
.hpos
+= len
;
5409 output_cursor
.x
+= shift_by_width
;
5414 /* Delete N glyphs at the nominal cursor position. Not implemented
5425 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
5426 If they are <= 0, this is probably an error. */
5429 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
5436 xassert (width
> 0 && height
> 0);
5437 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
5441 /* Erase the current text line from the nominal cursor position
5442 (inclusive) to pixel column TO_X (exclusive). The idea is that
5443 everything from TO_X onward is already erased.
5445 TO_X is a pixel position relative to updated_area of
5446 updated_window. TO_X == -1 means clear to the end of this area. */
5449 x_clear_end_of_line (to_x
)
5453 struct window
*w
= updated_window
;
5454 int max_x
, min_y
, max_y
;
5455 int from_x
, from_y
, to_y
;
5457 xassert (updated_window
&& updated_row
);
5458 f
= XFRAME (w
->frame
);
5460 if (updated_row
->full_width_p
)
5462 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5463 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5464 && !w
->pseudo_window_p
)
5465 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5468 max_x
= window_box_width (w
, updated_area
);
5469 max_y
= window_text_bottom_y (w
);
5471 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5472 of window. For TO_X > 0, truncate to end of drawing area. */
5478 to_x
= min (to_x
, max_x
);
5480 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5482 /* Notice if the cursor will be cleared by this operation. */
5483 if (!updated_row
->full_width_p
)
5484 notice_overwritten_cursor (w
, updated_area
,
5485 output_cursor
.x
, -1,
5487 MATRIX_ROW_BOTTOM_Y (updated_row
));
5489 from_x
= output_cursor
.x
;
5491 /* Translate to frame coordinates. */
5492 if (updated_row
->full_width_p
)
5494 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5495 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5499 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5500 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5503 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5504 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5505 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5507 /* Prevent inadvertently clearing to end of the X window. */
5508 if (to_x
> from_x
&& to_y
> from_y
)
5511 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5512 from_x
, from_y
, to_x
- from_x
, to_y
- from_y
,
5519 /* Clear entire frame. If updating_frame is non-null, clear that
5520 frame. Otherwise clear the selected frame. */
5530 f
= SELECTED_FRAME ();
5532 /* Clearing the frame will erase any cursor, so mark them all as no
5534 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5535 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5536 output_cursor
.x
= -1;
5538 /* We don't set the output cursor here because there will always
5539 follow an explicit cursor_to. */
5541 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5543 /* We have to clear the scroll bars, too. If we have changed
5544 colors or something like that, then they should be notified. */
5545 x_scroll_bar_clear (f
);
5547 XFlush (FRAME_X_DISPLAY (f
));
5553 /* Invert the middle quarter of the frame for .15 sec. */
5555 /* We use the select system call to do the waiting, so we have to make
5556 sure it's available. If it isn't, we just won't do visual bells. */
5558 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5561 /* Subtract the `struct timeval' values X and Y, storing the result in
5562 *RESULT. Return 1 if the difference is negative, otherwise 0. */
5565 timeval_subtract (result
, x
, y
)
5566 struct timeval
*result
, x
, y
;
5568 /* Perform the carry for the later subtraction by updating y. This
5569 is safer because on some systems the tv_sec member is unsigned. */
5570 if (x
.tv_usec
< y
.tv_usec
)
5572 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
5573 y
.tv_usec
-= 1000000 * nsec
;
5577 if (x
.tv_usec
- y
.tv_usec
> 1000000)
5579 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
5580 y
.tv_usec
+= 1000000 * nsec
;
5584 /* Compute the time remaining to wait. tv_usec is certainly
5586 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
5587 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
5589 /* Return indication of whether the result should be considered
5591 return x
.tv_sec
< y
.tv_sec
;
5603 /* Create a GC that will use the GXxor function to flip foreground
5604 pixels into background pixels. */
5608 values
.function
= GXxor
;
5609 values
.foreground
= (f
->output_data
.x
->foreground_pixel
5610 ^ f
->output_data
.x
->background_pixel
);
5612 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5613 GCFunction
| GCForeground
, &values
);
5617 /* Get the height not including a menu bar widget. */
5618 int height
= CHAR_TO_PIXEL_HEIGHT (f
, FRAME_HEIGHT (f
));
5619 /* Height of each line to flash. */
5620 int flash_height
= FRAME_LINE_HEIGHT (f
);
5621 /* These will be the left and right margins of the rectangles. */
5622 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
5623 int flash_right
= PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
5627 /* Don't flash the area between a scroll bar and the frame
5628 edge it is next to. */
5629 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
5631 case vertical_scroll_bar_left
:
5632 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5635 case vertical_scroll_bar_right
:
5636 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5643 width
= flash_right
- flash_left
;
5645 /* If window is tall, flash top and bottom line. */
5646 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5648 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5650 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5651 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5652 width
, flash_height
);
5653 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5655 (height
- flash_height
5656 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5657 width
, flash_height
);
5660 /* If it is short, flash it all. */
5661 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5662 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5663 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5668 struct timeval wakeup
;
5670 EMACS_GET_TIME (wakeup
);
5672 /* Compute time to wait until, propagating carry from usecs. */
5673 wakeup
.tv_usec
+= 150000;
5674 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
5675 wakeup
.tv_usec
%= 1000000;
5677 /* Keep waiting until past the time wakeup or any input gets
5679 while (! detect_input_pending ())
5681 struct timeval current
;
5682 struct timeval timeout
;
5684 EMACS_GET_TIME (current
);
5686 /* Break if result would be negative. */
5687 if (timeval_subtract (¤t
, wakeup
, current
))
5690 /* How long `select' should wait. */
5692 timeout
.tv_usec
= 10000;
5694 /* Try to wait that long--but we might wake up sooner. */
5695 select (0, NULL
, NULL
, NULL
, &timeout
);
5699 /* If window is tall, flash top and bottom line. */
5700 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5702 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5704 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5705 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5706 width
, flash_height
);
5707 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5709 (height
- flash_height
5710 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5711 width
, flash_height
);
5714 /* If it is short, flash it all. */
5715 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5716 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5717 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5719 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5727 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5730 /* Make audible bell. */
5735 struct frame
*f
= SELECTED_FRAME ();
5737 if (FRAME_X_DISPLAY (f
))
5739 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5746 XBell (FRAME_X_DISPLAY (f
), 0);
5747 XFlush (FRAME_X_DISPLAY (f
));
5754 /* Specify how many text lines, from the top of the window,
5755 should be affected by insert-lines and delete-lines operations.
5756 This, and those operations, are used only within an update
5757 that is bounded by calls to x_update_begin and x_update_end. */
5760 XTset_terminal_window (n
)
5763 /* This function intentionally left blank. */
5768 /***********************************************************************
5770 ***********************************************************************/
5772 /* Perform an insert-lines or delete-lines operation, inserting N
5773 lines or deleting -N lines at vertical position VPOS. */
5776 x_ins_del_lines (vpos
, n
)
5783 /* Scroll part of the display as described by RUN. */
5786 x_scroll_run (w
, run
)
5790 struct frame
*f
= XFRAME (w
->frame
);
5791 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5793 /* Get frame-relative bounding box of the text display area of W,
5794 without mode lines. Include in this box the left and right
5796 window_box (w
, -1, &x
, &y
, &width
, &height
);
5797 width
+= FRAME_X_FRINGE_WIDTH (f
);
5798 x
-= FRAME_X_LEFT_FRINGE_WIDTH (f
);
5800 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5801 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5802 bottom_y
= y
+ height
;
5806 /* Scrolling up. Make sure we don't copy part of the mode
5807 line at the bottom. */
5808 if (from_y
+ run
->height
> bottom_y
)
5809 height
= bottom_y
- from_y
;
5811 height
= run
->height
;
5815 /* Scolling down. Make sure we don't copy over the mode line.
5817 if (to_y
+ run
->height
> bottom_y
)
5818 height
= bottom_y
- to_y
;
5820 height
= run
->height
;
5825 /* Cursor off. Will be switched on again in x_update_window_end. */
5829 XCopyArea (FRAME_X_DISPLAY (f
),
5830 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5831 f
->output_data
.x
->normal_gc
,
5841 /***********************************************************************
5843 ***********************************************************************/
5845 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5846 corner of the exposed rectangle. W and H are width and height of
5847 the exposed area. All are pixel values. W or H zero means redraw
5848 the entire frame. */
5851 expose_frame (f
, x
, y
, w
, h
)
5856 int mouse_face_overwritten_p
= 0;
5858 TRACE ((stderr
, "expose_frame "));
5860 /* No need to redraw if frame will be redrawn soon. */
5861 if (FRAME_GARBAGED_P (f
))
5863 TRACE ((stderr
, " garbaged\n"));
5867 /* If basic faces haven't been realized yet, there is no point in
5868 trying to redraw anything. This can happen when we get an expose
5869 event while Emacs is starting, e.g. by moving another window. */
5870 if (FRAME_FACE_CACHE (f
) == NULL
5871 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5873 TRACE ((stderr
, " no faces\n"));
5877 if (w
== 0 || h
== 0)
5880 r
.width
= CANON_X_UNIT (f
) * f
->width
;
5881 r
.height
= CANON_Y_UNIT (f
) * f
->height
;
5891 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
5892 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
5894 if (WINDOWP (f
->tool_bar_window
))
5895 mouse_face_overwritten_p
5896 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
5898 #ifndef USE_X_TOOLKIT
5899 if (WINDOWP (f
->menu_bar_window
))
5900 mouse_face_overwritten_p
5901 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
5902 #endif /* not USE_X_TOOLKIT */
5904 /* Some window managers support a focus-follows-mouse style with
5905 delayed raising of frames. Imagine a partially obscured frame,
5906 and moving the mouse into partially obscured mouse-face on that
5907 frame. The visible part of the mouse-face will be highlighted,
5908 then the WM raises the obscured frame. With at least one WM, KDE
5909 2.1, Emacs is not getting any event for the raising of the frame
5910 (even tried with SubstructureRedirectMask), only Expose events.
5911 These expose events will draw text normally, i.e. not
5912 highlighted. Which means we must redo the highlight here.
5913 Subsume it under ``we love X''. --gerd 2001-08-15 */
5914 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
5916 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5917 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5919 int x
= dpyinfo
->mouse_face_mouse_x
;
5920 int y
= dpyinfo
->mouse_face_mouse_y
;
5921 clear_mouse_face (dpyinfo
);
5922 note_mouse_highlight (f
, x
, y
);
5928 /* Redraw (parts) of all windows in the window tree rooted at W that
5929 intersect R. R contains frame pixel coordinates. Value is
5930 non-zero if the exposure overwrites mouse-face. */
5933 expose_window_tree (w
, r
)
5937 struct frame
*f
= XFRAME (w
->frame
);
5938 int mouse_face_overwritten_p
= 0;
5940 while (w
&& !FRAME_GARBAGED_P (f
))
5942 if (!NILP (w
->hchild
))
5943 mouse_face_overwritten_p
5944 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
5945 else if (!NILP (w
->vchild
))
5946 mouse_face_overwritten_p
5947 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
5949 mouse_face_overwritten_p
|= expose_window (w
, r
);
5951 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
5954 return mouse_face_overwritten_p
;
5958 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5959 which intersects rectangle R. R is in window-relative coordinates. */
5962 expose_area (w
, row
, r
, area
)
5964 struct glyph_row
*row
;
5966 enum glyph_row_area area
;
5968 struct glyph
*first
= row
->glyphs
[area
];
5969 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5971 int first_x
, start_x
, x
;
5973 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5974 /* If row extends face to end of line write the whole line. */
5975 x_draw_glyphs (w
, 0, row
, area
, 0, row
->used
[area
],
5976 DRAW_NORMAL_TEXT
, 0);
5979 /* Set START_X to the window-relative start position for drawing glyphs of
5980 AREA. The first glyph of the text area can be partially visible.
5981 The first glyphs of other areas cannot. */
5982 if (area
== LEFT_MARGIN_AREA
)
5984 else if (area
== TEXT_AREA
)
5985 start_x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5987 start_x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5988 + window_box_width (w
, TEXT_AREA
));
5991 /* Find the first glyph that must be redrawn. */
5993 && x
+ first
->pixel_width
< r
->x
)
5995 x
+= first
->pixel_width
;
5999 /* Find the last one. */
6003 && x
< r
->x
+ r
->width
)
6005 x
+= last
->pixel_width
;
6011 x_draw_glyphs (w
, first_x
- start_x
, row
, area
,
6012 first
- row
->glyphs
[area
],
6013 last
- row
->glyphs
[area
],
6014 DRAW_NORMAL_TEXT
, 0);
6019 /* Redraw the parts of the glyph row ROW on window W intersecting
6020 rectangle R. R is in window-relative coordinates. Value is
6021 non-zero if mouse-face was overwritten. */
6024 expose_line (w
, row
, r
)
6026 struct glyph_row
*row
;
6029 xassert (row
->enabled_p
);
6031 if (row
->mode_line_p
|| w
->pseudo_window_p
)
6032 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
6033 DRAW_NORMAL_TEXT
, 0);
6036 if (row
->used
[LEFT_MARGIN_AREA
])
6037 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
6038 if (row
->used
[TEXT_AREA
])
6039 expose_area (w
, row
, r
, TEXT_AREA
);
6040 if (row
->used
[RIGHT_MARGIN_AREA
])
6041 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
6042 x_draw_row_fringe_bitmaps (w
, row
);
6045 return row
->mouse_face_p
;
6049 /* Return non-zero if W's cursor intersects rectangle R. */
6052 x_phys_cursor_in_rect_p (w
, r
)
6056 XRectangle cr
, result
;
6057 struct glyph
*cursor_glyph
;
6059 cursor_glyph
= get_phys_cursor_glyph (w
);
6062 cr
.x
= w
->phys_cursor
.x
;
6063 cr
.y
= w
->phys_cursor
.y
;
6064 cr
.width
= cursor_glyph
->pixel_width
;
6065 cr
.height
= w
->phys_cursor_height
;
6066 return x_intersect_rectangles (&cr
, r
, &result
);
6073 /* Redraw the part of window W intersection rectangle FR. Pixel
6074 coordinates in FR are frame-relative. Call this function with
6075 input blocked. Value is non-zero if the exposure overwrites
6079 expose_window (w
, fr
)
6083 struct frame
*f
= XFRAME (w
->frame
);
6085 int mouse_face_overwritten_p
= 0;
6087 /* If window is not yet fully initialized, do nothing. This can
6088 happen when toolkit scroll bars are used and a window is split.
6089 Reconfiguring the scroll bar will generate an expose for a newly
6091 if (w
->current_matrix
== NULL
)
6094 /* When we're currently updating the window, display and current
6095 matrix usually don't agree. Arrange for a thorough display
6097 if (w
== updated_window
)
6099 SET_FRAME_GARBAGED (f
);
6103 /* Frame-relative pixel rectangle of W. */
6104 wr
.x
= XFASTINT (w
->left
) * CANON_X_UNIT (f
);
6105 wr
.y
= XFASTINT (w
->top
) * CANON_Y_UNIT (f
);
6106 wr
.width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
6107 wr
.height
= XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
6109 if (x_intersect_rectangles (fr
, &wr
, &r
))
6111 int yb
= window_text_bottom_y (w
);
6112 struct glyph_row
*row
;
6113 int cursor_cleared_p
;
6115 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
6116 r
.x
, r
.y
, r
.width
, r
.height
));
6118 /* Convert to window coordinates. */
6119 r
.x
= FRAME_TO_WINDOW_PIXEL_X (w
, r
.x
);
6120 r
.y
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
.y
);
6122 /* Turn off the cursor. */
6123 if (!w
->pseudo_window_p
6124 && x_phys_cursor_in_rect_p (w
, &r
))
6127 cursor_cleared_p
= 1;
6130 cursor_cleared_p
= 0;
6132 /* Find the first row intersecting the rectangle R. */
6133 for (row
= w
->current_matrix
->rows
;
6138 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
6140 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
6141 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
6142 || (r
.y
>= y0
&& r
.y
< y1
)
6143 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
6145 if (expose_line (w
, row
, &r
))
6146 mouse_face_overwritten_p
= 1;
6153 /* Display the mode line if there is one. */
6154 if (WINDOW_WANTS_MODELINE_P (w
)
6155 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
6157 && row
->y
< r
.y
+ r
.height
)
6159 if (expose_line (w
, row
, &r
))
6160 mouse_face_overwritten_p
= 1;
6163 if (!w
->pseudo_window_p
)
6165 /* Draw border between windows. */
6166 x_draw_vertical_border (w
);
6168 /* Turn the cursor on again. */
6169 if (cursor_cleared_p
)
6170 x_update_window_cursor (w
, 1);
6174 return mouse_face_overwritten_p
;
6178 /* Determine the intersection of two rectangles R1 and R2. Return
6179 the intersection in *RESULT. Value is non-zero if RESULT is not
6183 x_intersect_rectangles (r1
, r2
, result
)
6184 XRectangle
*r1
, *r2
, *result
;
6186 XRectangle
*left
, *right
;
6187 XRectangle
*upper
, *lower
;
6188 int intersection_p
= 0;
6190 /* Rearrange so that R1 is the left-most rectangle. */
6192 left
= r1
, right
= r2
;
6194 left
= r2
, right
= r1
;
6196 /* X0 of the intersection is right.x0, if this is inside R1,
6197 otherwise there is no intersection. */
6198 if (right
->x
<= left
->x
+ left
->width
)
6200 result
->x
= right
->x
;
6202 /* The right end of the intersection is the minimum of the
6203 the right ends of left and right. */
6204 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
6207 /* Same game for Y. */
6209 upper
= r1
, lower
= r2
;
6211 upper
= r2
, lower
= r1
;
6213 /* The upper end of the intersection is lower.y0, if this is inside
6214 of upper. Otherwise, there is no intersection. */
6215 if (lower
->y
<= upper
->y
+ upper
->height
)
6217 result
->y
= lower
->y
;
6219 /* The lower end of the intersection is the minimum of the lower
6220 ends of upper and lower. */
6221 result
->height
= (min (lower
->y
+ lower
->height
,
6222 upper
->y
+ upper
->height
)
6228 return intersection_p
;
6239 /* We used to only do this if Vx_no_window_manager was non-nil, but
6240 the ICCCM (section 4.1.6) says that the window's border pixmap
6241 and border pixel are window attributes which are "private to the
6242 client", so we can always change it to whatever we want. */
6244 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6245 f
->output_data
.x
->border_pixel
);
6247 x_update_cursor (f
, 1);
6251 frame_unhighlight (f
)
6254 /* We used to only do this if Vx_no_window_manager was non-nil, but
6255 the ICCCM (section 4.1.6) says that the window's border pixmap
6256 and border pixel are window attributes which are "private to the
6257 client", so we can always change it to whatever we want. */
6259 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6260 f
->output_data
.x
->border_tile
);
6262 x_update_cursor (f
, 1);
6265 /* The focus has changed. Update the frames as necessary to reflect
6266 the new situation. Note that we can't change the selected frame
6267 here, because the Lisp code we are interrupting might become confused.
6268 Each event gets marked with the frame in which it occurred, so the
6269 Lisp code can tell when the switch took place by examining the events. */
6272 x_new_focus_frame (dpyinfo
, frame
)
6273 struct x_display_info
*dpyinfo
;
6274 struct frame
*frame
;
6276 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
6278 if (frame
!= dpyinfo
->x_focus_frame
)
6280 /* Set this before calling other routines, so that they see
6281 the correct value of x_focus_frame. */
6282 dpyinfo
->x_focus_frame
= frame
;
6284 if (old_focus
&& old_focus
->auto_lower
)
6285 x_lower_frame (old_focus
);
6288 selected_frame
= frame
;
6289 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
6291 Fselect_window (selected_frame
->selected_window
);
6292 choose_minibuf_frame ();
6295 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
6296 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
6298 pending_autoraise_frame
= 0;
6301 x_frame_rehighlight (dpyinfo
);
6304 /* Handle FocusIn and FocusOut state changes for FRAME.
6305 If FRAME has focus and there exists more than one frame, puts
6306 an FOCUS_IN_EVENT into BUFP.
6307 Returns number of events inserted into BUFP. */
6310 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
, numchars
)
6313 struct x_display_info
*dpyinfo
;
6314 struct frame
*frame
;
6315 struct input_event
*bufp
;
6320 if (type
== FocusIn
)
6322 if (dpyinfo
->x_focus_event_frame
!= frame
)
6324 x_new_focus_frame (dpyinfo
, frame
);
6325 dpyinfo
->x_focus_event_frame
= frame
;
6327 /* Don't stop displaying the initial startup message
6328 for a switch-frame event we don't need. */
6330 && GC_NILP (Vterminal_frame
)
6331 && GC_CONSP (Vframe_list
)
6332 && !GC_NILP (XCDR (Vframe_list
)))
6334 bufp
->kind
= FOCUS_IN_EVENT
;
6335 XSETFRAME (bufp
->frame_or_window
, frame
);
6343 frame
->output_data
.x
->focus_state
|= state
;
6346 if (FRAME_XIC (frame
))
6347 XSetICFocus (FRAME_XIC (frame
));
6350 else if (type
== FocusOut
)
6352 frame
->output_data
.x
->focus_state
&= ~state
;
6354 if (dpyinfo
->x_focus_event_frame
== frame
)
6356 dpyinfo
->x_focus_event_frame
= 0;
6357 x_new_focus_frame (dpyinfo
, 0);
6361 if (FRAME_XIC (frame
))
6362 XUnsetICFocus (FRAME_XIC (frame
));
6369 /* The focus may have changed. Figure out if it is a real focus change,
6370 by checking both FocusIn/Out and Enter/LeaveNotify events.
6372 Returns number of events inserted into BUFP. */
6375 x_detect_focus_change (dpyinfo
, event
, bufp
, numchars
)
6376 struct x_display_info
*dpyinfo
;
6378 struct input_event
*bufp
;
6381 struct frame
*frame
;
6384 frame
= x_top_window_to_frame (dpyinfo
, event
->xany
.window
);
6385 if (! frame
) return nr_events
;
6387 switch (event
->type
)
6391 if (event
->xcrossing
.detail
!= NotifyInferior
6392 && event
->xcrossing
.focus
6393 && ! (frame
->output_data
.x
->focus_state
& FOCUS_EXPLICIT
))
6394 nr_events
= x_focus_changed ((event
->type
== EnterNotify
6395 ? FocusIn
: FocusOut
),
6405 nr_events
= x_focus_changed (event
->type
,
6406 (event
->xfocus
.detail
== NotifyPointer
6407 ? FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
6419 /* Handle an event saying the mouse has moved out of an Emacs frame. */
6422 x_mouse_leave (dpyinfo
)
6423 struct x_display_info
*dpyinfo
;
6425 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
6428 /* The focus has changed, or we have redirected a frame's focus to
6429 another frame (this happens when a frame uses a surrogate
6430 mini-buffer frame). Shift the highlight as appropriate.
6432 The FRAME argument doesn't necessarily have anything to do with which
6433 frame is being highlighted or un-highlighted; we only use it to find
6434 the appropriate X display info. */
6437 XTframe_rehighlight (frame
)
6438 struct frame
*frame
;
6440 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
6444 x_frame_rehighlight (dpyinfo
)
6445 struct x_display_info
*dpyinfo
;
6447 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
6449 if (dpyinfo
->x_focus_frame
)
6451 dpyinfo
->x_highlight_frame
6452 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
6453 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
6454 : dpyinfo
->x_focus_frame
);
6455 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
6457 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
6458 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
6462 dpyinfo
->x_highlight_frame
= 0;
6464 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
6467 frame_unhighlight (old_highlight
);
6468 if (dpyinfo
->x_highlight_frame
)
6469 frame_highlight (dpyinfo
->x_highlight_frame
);
6475 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
6477 /* Initialize mode_switch_bit and modifier_meaning. */
6479 x_find_modifier_meanings (dpyinfo
)
6480 struct x_display_info
*dpyinfo
;
6482 int min_code
, max_code
;
6485 XModifierKeymap
*mods
;
6487 dpyinfo
->meta_mod_mask
= 0;
6488 dpyinfo
->shift_lock_mask
= 0;
6489 dpyinfo
->alt_mod_mask
= 0;
6490 dpyinfo
->super_mod_mask
= 0;
6491 dpyinfo
->hyper_mod_mask
= 0;
6494 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
6496 min_code
= dpyinfo
->display
->min_keycode
;
6497 max_code
= dpyinfo
->display
->max_keycode
;
6500 syms
= XGetKeyboardMapping (dpyinfo
->display
,
6501 min_code
, max_code
- min_code
+ 1,
6503 mods
= XGetModifierMapping (dpyinfo
->display
);
6505 /* Scan the modifier table to see which modifier bits the Meta and
6506 Alt keysyms are on. */
6508 int row
, col
; /* The row and column in the modifier table. */
6510 for (row
= 3; row
< 8; row
++)
6511 for (col
= 0; col
< mods
->max_keypermod
; col
++)
6514 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
6516 /* Zeroes are used for filler. Skip them. */
6520 /* Are any of this keycode's keysyms a meta key? */
6524 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
6526 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
6532 dpyinfo
->meta_mod_mask
|= (1 << row
);
6537 dpyinfo
->alt_mod_mask
|= (1 << row
);
6542 dpyinfo
->hyper_mod_mask
|= (1 << row
);
6547 dpyinfo
->super_mod_mask
|= (1 << row
);
6551 /* Ignore this if it's not on the lock modifier. */
6552 if ((1 << row
) == LockMask
)
6553 dpyinfo
->shift_lock_mask
= LockMask
;
6561 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
6562 if (! dpyinfo
->meta_mod_mask
)
6564 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
6565 dpyinfo
->alt_mod_mask
= 0;
6568 /* If some keys are both alt and meta,
6569 make them just meta, not alt. */
6570 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
6572 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
6575 XFree ((char *) syms
);
6576 XFreeModifiermap (mods
);
6579 /* Convert between the modifier bits X uses and the modifier bits
6583 x_x_to_emacs_modifiers (dpyinfo
, state
)
6584 struct x_display_info
*dpyinfo
;
6587 EMACS_UINT mod_meta
= meta_modifier
;
6588 EMACS_UINT mod_alt
= alt_modifier
;
6589 EMACS_UINT mod_hyper
= hyper_modifier
;
6590 EMACS_UINT mod_super
= super_modifier
;
6593 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
6594 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
6595 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
6596 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
6597 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
6598 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
6599 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
6600 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
6603 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
6604 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
6605 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
6606 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
6607 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
6608 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
6612 x_emacs_to_x_modifiers (dpyinfo
, state
)
6613 struct x_display_info
*dpyinfo
;
6616 EMACS_UINT mod_meta
= meta_modifier
;
6617 EMACS_UINT mod_alt
= alt_modifier
;
6618 EMACS_UINT mod_hyper
= hyper_modifier
;
6619 EMACS_UINT mod_super
= super_modifier
;
6623 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
6624 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
6625 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
6626 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
6627 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
6628 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
6629 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
6630 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
6633 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
6634 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
6635 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
6636 | ((state
& shift_modifier
) ? ShiftMask
: 0)
6637 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
6638 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
6641 /* Convert a keysym to its name. */
6644 x_get_keysym_name (keysym
)
6650 value
= XKeysymToString (keysym
);
6658 /* Mouse clicks and mouse movement. Rah. */
6660 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6661 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6662 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6663 not force the value into range. */
6666 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
6668 register int pix_x
, pix_y
;
6669 register int *x
, *y
;
6673 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6674 even for negative values. */
6676 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
6678 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
6680 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
6681 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
6685 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
6686 bounds
->height
= f
->output_data
.x
->line_height
;
6687 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
6688 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
6695 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
6696 pix_x
= FRAME_WINDOW_WIDTH (f
);
6700 else if (pix_y
> f
->height
)
6709 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6710 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6711 can't tell the positions because W's display is not up to date,
6715 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
6718 int *frame_x
, *frame_y
;
6722 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
6723 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
6725 if (display_completed
)
6727 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6728 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
6729 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
6735 *frame_x
+= glyph
->pixel_width
;
6743 *frame_y
= *frame_x
= 0;
6747 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6748 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6753 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6755 If the event is a button press, then note that we have grabbed
6759 construct_mouse_click (result
, event
, f
)
6760 struct input_event
*result
;
6761 XButtonEvent
*event
;
6764 /* Make the event type NO_EVENT; we'll change that when we decide
6766 result
->kind
= MOUSE_CLICK_EVENT
;
6767 result
->code
= event
->button
- Button1
;
6768 result
->timestamp
= event
->time
;
6769 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6771 | (event
->type
== ButtonRelease
6775 XSETINT (result
->x
, event
->x
);
6776 XSETINT (result
->y
, event
->y
);
6777 XSETFRAME (result
->frame_or_window
, f
);
6783 /* Function to report a mouse movement to the mainstream Emacs code.
6784 The input handler calls this.
6786 We have received a mouse movement event, which is given in *event.
6787 If the mouse is over a different glyph than it was last time, tell
6788 the mainstream emacs code by setting mouse_moved. If not, ask for
6789 another motion event, so we can check again the next time it moves. */
6791 static XMotionEvent last_mouse_motion_event
;
6792 static Lisp_Object last_mouse_motion_frame
;
6795 note_mouse_movement (frame
, event
)
6797 XMotionEvent
*event
;
6799 last_mouse_movement_time
= event
->time
;
6800 last_mouse_motion_event
= *event
;
6801 XSETFRAME (last_mouse_motion_frame
, frame
);
6803 if (event
->window
!= FRAME_X_WINDOW (frame
))
6805 frame
->mouse_moved
= 1;
6806 last_mouse_scroll_bar
= Qnil
;
6807 note_mouse_highlight (frame
, -1, -1);
6810 /* Has the mouse moved off the glyph it was on at the last sighting? */
6811 else if (event
->x
< last_mouse_glyph
.x
6812 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
6813 || event
->y
< last_mouse_glyph
.y
6814 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
6816 frame
->mouse_moved
= 1;
6817 last_mouse_scroll_bar
= Qnil
;
6818 note_mouse_highlight (frame
, event
->x
, event
->y
);
6823 /************************************************************************
6825 ************************************************************************/
6827 /* Find the glyph under window-relative coordinates X/Y in window W.
6828 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6829 strings. Return in *HPOS and *VPOS the row and column number of
6830 the glyph found. Return in *AREA the glyph area containing X.
6831 Value is a pointer to the glyph found or null if X/Y is not on
6832 text, or we can't tell because W's current matrix is not up to
6835 static struct glyph
*
6836 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
, buffer_only_p
)
6839 int *hpos
, *vpos
, *area
;
6842 struct glyph
*glyph
, *end
;
6843 struct glyph_row
*row
= NULL
;
6844 int x0
, i
, left_area_width
;
6846 /* Find row containing Y. Give up if some row is not enabled. */
6847 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6849 row
= MATRIX_ROW (w
->current_matrix
, i
);
6850 if (!row
->enabled_p
)
6852 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6859 /* Give up if Y is not in the window. */
6860 if (i
== w
->current_matrix
->nrows
)
6863 /* Get the glyph area containing X. */
6864 if (w
->pseudo_window_p
)
6871 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6872 if (x
< left_area_width
)
6874 *area
= LEFT_MARGIN_AREA
;
6877 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6880 x0
= row
->x
+ left_area_width
;
6884 *area
= RIGHT_MARGIN_AREA
;
6885 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6889 /* Find glyph containing X. */
6890 glyph
= row
->glyphs
[*area
];
6891 end
= glyph
+ row
->used
[*area
];
6894 if (x
< x0
+ glyph
->pixel_width
)
6896 if (w
->pseudo_window_p
)
6898 else if (!buffer_only_p
|| BUFFERP (glyph
->object
))
6902 x0
+= glyph
->pixel_width
;
6909 *hpos
= glyph
- row
->glyphs
[*area
];
6914 /* Convert frame-relative x/y to coordinates relative to window W.
6915 Takes pseudo-windows into account. */
6918 frame_to_window_pixel_xy (w
, x
, y
)
6922 if (w
->pseudo_window_p
)
6924 /* A pseudo-window is always full-width, and starts at the
6925 left edge of the frame, plus a frame border. */
6926 struct frame
*f
= XFRAME (w
->frame
);
6927 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6928 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6932 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6933 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6938 /* Take proper action when mouse has moved to the mode or header line
6939 or marginal area of window W, x-position X and y-position Y. Area
6940 is 1, 3, 6 or 7 for the mode line, header line, left and right
6941 marginal area respectively. X is relative to the start of the text
6942 display area of W, so the width of bitmap areas and scroll bars
6943 must be subtracted to get a position relative to the start of the
6947 note_mode_line_or_margin_highlight (w
, x
, y
, portion
)
6951 struct frame
*f
= XFRAME (w
->frame
);
6952 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6953 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6955 Lisp_Object string
, help
, map
, pos
;
6957 if (portion
== 1 || portion
== 3)
6958 string
= mode_line_string (w
, x
, y
, portion
== 1, &charpos
);
6960 string
= marginal_area_string (w
, x
, y
, portion
, &charpos
);
6962 if (STRINGP (string
))
6964 pos
= make_number (charpos
);
6966 /* If we're on a string with `help-echo' text property, arrange
6967 for the help to be displayed. This is done by setting the
6968 global variable help_echo to the help string. */
6969 help
= Fget_text_property (pos
, Qhelp_echo
, string
);
6973 XSETWINDOW (help_echo_window
, w
);
6974 help_echo_object
= string
;
6975 help_echo_pos
= charpos
;
6978 /* Change the mouse pointer according to what is under X/Y. */
6979 map
= Fget_text_property (pos
, Qlocal_map
, string
);
6981 map
= Fget_text_property (pos
, Qkeymap
, string
);
6983 cursor
= f
->output_data
.x
->nontext_cursor
;
6986 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6990 /* Take proper action when the mouse has moved to position X, Y on
6991 frame F as regards highlighting characters that have mouse-face
6992 properties. Also de-highlighting chars where the mouse was before.
6993 X and Y can be negative or out of range. */
6996 note_mouse_highlight (f
, x
, y
)
7000 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7004 Cursor cursor
= None
;
7007 /* When a menu is active, don't highlight because this looks odd. */
7008 #ifdef USE_X_TOOLKIT
7009 if (popup_activated ())
7013 if (NILP (Vmouse_highlight
)
7014 || !f
->glyphs_initialized_p
)
7017 dpyinfo
->mouse_face_mouse_x
= x
;
7018 dpyinfo
->mouse_face_mouse_y
= y
;
7019 dpyinfo
->mouse_face_mouse_frame
= f
;
7021 if (dpyinfo
->mouse_face_defer
)
7026 dpyinfo
->mouse_face_deferred_gc
= 1;
7030 /* Which window is that in? */
7031 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
7033 /* If we were displaying active text in another window, clear that. */
7034 if (! EQ (window
, dpyinfo
->mouse_face_window
))
7035 clear_mouse_face (dpyinfo
);
7037 /* Not on a window -> return. */
7038 if (!WINDOWP (window
))
7041 /* Convert to window-relative pixel coordinates. */
7042 w
= XWINDOW (window
);
7043 frame_to_window_pixel_xy (w
, &x
, &y
);
7045 /* Handle tool-bar window differently since it doesn't display a
7047 if (EQ (window
, f
->tool_bar_window
))
7049 note_tool_bar_highlight (f
, x
, y
);
7053 /* Mouse is on the mode, header line or margin? */
7054 if (portion
== 1 || portion
== 3 || portion
== 6 || portion
== 7)
7056 note_mode_line_or_margin_highlight (w
, x
, y
, portion
);
7061 cursor
= f
->output_data
.x
->horizontal_drag_cursor
;
7063 cursor
= f
->output_data
.x
->text_cursor
;
7065 /* Are we in a window whose display is up to date?
7066 And verify the buffer's text has not changed. */
7067 b
= XBUFFER (w
->buffer
);
7068 if (/* Within text portion of the window. */
7070 && EQ (w
->window_end_valid
, w
->buffer
)
7071 && XFASTINT (w
->last_modified
) == BUF_MODIFF (b
)
7072 && XFASTINT (w
->last_overlay_modified
) == BUF_OVERLAY_MODIFF (b
))
7074 int hpos
, vpos
, pos
, i
, area
;
7075 struct glyph
*glyph
;
7077 Lisp_Object mouse_face
= Qnil
, overlay
= Qnil
, position
;
7078 Lisp_Object
*overlay_vec
= NULL
;
7080 struct buffer
*obuf
;
7081 int obegv
, ozv
, same_region
;
7083 /* Find the glyph under X/Y. */
7084 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
, 0);
7086 /* Clear mouse face if X/Y not over text. */
7088 || area
!= TEXT_AREA
7089 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
7091 if (clear_mouse_face (dpyinfo
))
7096 pos
= glyph
->charpos
;
7097 object
= glyph
->object
;
7098 if (!STRINGP (object
) && !BUFFERP (object
))
7101 /* If we get an out-of-range value, return now; avoid an error. */
7102 if (BUFFERP (object
) && pos
> BUF_Z (b
))
7105 /* Make the window's buffer temporarily current for
7106 overlays_at and compute_char_face. */
7107 obuf
= current_buffer
;
7114 /* Is this char mouse-active or does it have help-echo? */
7115 position
= make_number (pos
);
7117 if (BUFFERP (object
))
7119 /* Put all the overlays we want in a vector in overlay_vec.
7120 Store the length in len. If there are more than 10, make
7121 enough space for all, and try again. */
7123 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
7124 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
7125 if (noverlays
> len
)
7128 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
7129 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
,0);
7132 /* Sort overlays into increasing priority order. */
7133 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
7138 same_region
= (EQ (window
, dpyinfo
->mouse_face_window
)
7139 && vpos
>= dpyinfo
->mouse_face_beg_row
7140 && vpos
<= dpyinfo
->mouse_face_end_row
7141 && (vpos
> dpyinfo
->mouse_face_beg_row
7142 || hpos
>= dpyinfo
->mouse_face_beg_col
)
7143 && (vpos
< dpyinfo
->mouse_face_end_row
7144 || hpos
< dpyinfo
->mouse_face_end_col
7145 || dpyinfo
->mouse_face_past_end
));
7150 /* Check mouse-face highlighting. */
7152 /* If there exists an overlay with mouse-face overlapping
7153 the one we are currently highlighting, we have to
7154 check if we enter the overlapping overlay, and then
7155 highlight only that. */
7156 || (OVERLAYP (dpyinfo
->mouse_face_overlay
)
7157 && mouse_face_overlay_overlaps (dpyinfo
->mouse_face_overlay
)))
7159 /* Find the highest priority overlay that has a mouse-face
7162 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
7164 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
7165 if (!NILP (mouse_face
))
7166 overlay
= overlay_vec
[i
];
7169 /* If we're actually highlighting the same overlay as
7170 before, there's no need to do that again. */
7172 && EQ (overlay
, dpyinfo
->mouse_face_overlay
))
7173 goto check_help_echo
;
7175 dpyinfo
->mouse_face_overlay
= overlay
;
7177 /* Clear the display of the old active region, if any. */
7178 if (clear_mouse_face (dpyinfo
))
7181 /* If no overlay applies, get a text property. */
7183 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
7185 /* Handle the overlay case. */
7186 if (!NILP (overlay
))
7188 /* Find the range of text around this char that
7189 should be active. */
7190 Lisp_Object before
, after
;
7193 before
= Foverlay_start (overlay
);
7194 after
= Foverlay_end (overlay
);
7195 /* Record this as the current active region. */
7196 fast_find_position (w
, XFASTINT (before
),
7197 &dpyinfo
->mouse_face_beg_col
,
7198 &dpyinfo
->mouse_face_beg_row
,
7199 &dpyinfo
->mouse_face_beg_x
,
7200 &dpyinfo
->mouse_face_beg_y
, Qnil
);
7202 dpyinfo
->mouse_face_past_end
7203 = !fast_find_position (w
, XFASTINT (after
),
7204 &dpyinfo
->mouse_face_end_col
,
7205 &dpyinfo
->mouse_face_end_row
,
7206 &dpyinfo
->mouse_face_end_x
,
7207 &dpyinfo
->mouse_face_end_y
, Qnil
);
7208 dpyinfo
->mouse_face_window
= window
;
7209 dpyinfo
->mouse_face_face_id
7210 = face_at_buffer_position (w
, pos
, 0, 0,
7211 &ignore
, pos
+ 1, 1);
7213 /* Display it as active. */
7214 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7217 /* Handle the text property case. */
7218 else if (!NILP (mouse_face
) && BUFFERP (object
))
7220 /* Find the range of text around this char that
7221 should be active. */
7222 Lisp_Object before
, after
, beginning
, end
;
7225 beginning
= Fmarker_position (w
->start
);
7226 end
= make_number (BUF_Z (XBUFFER (object
))
7227 - XFASTINT (w
->window_end_pos
));
7229 = Fprevious_single_property_change (make_number (pos
+ 1),
7233 = Fnext_single_property_change (position
, Qmouse_face
,
7236 /* Record this as the current active region. */
7237 fast_find_position (w
, XFASTINT (before
),
7238 &dpyinfo
->mouse_face_beg_col
,
7239 &dpyinfo
->mouse_face_beg_row
,
7240 &dpyinfo
->mouse_face_beg_x
,
7241 &dpyinfo
->mouse_face_beg_y
, Qnil
);
7242 dpyinfo
->mouse_face_past_end
7243 = !fast_find_position (w
, XFASTINT (after
),
7244 &dpyinfo
->mouse_face_end_col
,
7245 &dpyinfo
->mouse_face_end_row
,
7246 &dpyinfo
->mouse_face_end_x
,
7247 &dpyinfo
->mouse_face_end_y
, Qnil
);
7248 dpyinfo
->mouse_face_window
= window
;
7250 if (BUFFERP (object
))
7251 dpyinfo
->mouse_face_face_id
7252 = face_at_buffer_position (w
, pos
, 0, 0,
7253 &ignore
, pos
+ 1, 1);
7255 /* Display it as active. */
7256 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7259 else if (!NILP (mouse_face
) && STRINGP (object
))
7264 b
= Fprevious_single_property_change (make_number (pos
+ 1),
7267 e
= Fnext_single_property_change (position
, Qmouse_face
,
7270 b
= make_number (0);
7272 e
= make_number (SCHARS (object
) - 1);
7273 fast_find_string_pos (w
, XINT (b
), object
,
7274 &dpyinfo
->mouse_face_beg_col
,
7275 &dpyinfo
->mouse_face_beg_row
,
7276 &dpyinfo
->mouse_face_beg_x
,
7277 &dpyinfo
->mouse_face_beg_y
, 0);
7278 fast_find_string_pos (w
, XINT (e
), object
,
7279 &dpyinfo
->mouse_face_end_col
,
7280 &dpyinfo
->mouse_face_end_row
,
7281 &dpyinfo
->mouse_face_end_x
,
7282 &dpyinfo
->mouse_face_end_y
, 1);
7283 dpyinfo
->mouse_face_past_end
= 0;
7284 dpyinfo
->mouse_face_window
= window
;
7285 dpyinfo
->mouse_face_face_id
7286 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
7288 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7291 else if (STRINGP (object
) && NILP (mouse_face
))
7293 /* A string which doesn't have mouse-face, but
7294 the text ``under'' it might have. */
7295 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
7296 int start
= MATRIX_ROW_START_CHARPOS (r
);
7298 pos
= string_buffer_position (w
, object
, start
);
7300 mouse_face
= get_char_property_and_overlay (make_number (pos
),
7304 if (!NILP (mouse_face
) && !NILP (overlay
))
7306 Lisp_Object before
= Foverlay_start (overlay
);
7307 Lisp_Object after
= Foverlay_end (overlay
);
7310 /* Note that we might not be able to find position
7311 BEFORE in the glyph matrix if the overlay is
7312 entirely covered by a `display' property. In
7313 this case, we overshoot. So let's stop in
7314 the glyph matrix before glyphs for OBJECT. */
7315 fast_find_position (w
, XFASTINT (before
),
7316 &dpyinfo
->mouse_face_beg_col
,
7317 &dpyinfo
->mouse_face_beg_row
,
7318 &dpyinfo
->mouse_face_beg_x
,
7319 &dpyinfo
->mouse_face_beg_y
,
7322 dpyinfo
->mouse_face_past_end
7323 = !fast_find_position (w
, XFASTINT (after
),
7324 &dpyinfo
->mouse_face_end_col
,
7325 &dpyinfo
->mouse_face_end_row
,
7326 &dpyinfo
->mouse_face_end_x
,
7327 &dpyinfo
->mouse_face_end_y
,
7329 dpyinfo
->mouse_face_window
= window
;
7330 dpyinfo
->mouse_face_face_id
7331 = face_at_buffer_position (w
, pos
, 0, 0,
7332 &ignore
, pos
+ 1, 1);
7334 /* Display it as active. */
7335 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7343 /* Look for a `help-echo' property. */
7345 Lisp_Object help
, overlay
;
7347 /* Check overlays first. */
7348 help
= overlay
= Qnil
;
7349 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
7351 overlay
= overlay_vec
[i
];
7352 help
= Foverlay_get (overlay
, Qhelp_echo
);
7358 help_echo_window
= window
;
7359 help_echo_object
= overlay
;
7360 help_echo_pos
= pos
;
7364 Lisp_Object object
= glyph
->object
;
7365 int charpos
= glyph
->charpos
;
7367 /* Try text properties. */
7368 if (STRINGP (object
)
7370 && charpos
< SCHARS (object
))
7372 help
= Fget_text_property (make_number (charpos
),
7373 Qhelp_echo
, object
);
7376 /* If the string itself doesn't specify a help-echo,
7377 see if the buffer text ``under'' it does. */
7379 = MATRIX_ROW (w
->current_matrix
, vpos
);
7380 int start
= MATRIX_ROW_START_CHARPOS (r
);
7381 int pos
= string_buffer_position (w
, object
, start
);
7384 help
= Fget_char_property (make_number (pos
),
7385 Qhelp_echo
, w
->buffer
);
7394 else if (BUFFERP (object
)
7397 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
7403 help_echo_window
= window
;
7404 help_echo_object
= object
;
7405 help_echo_pos
= charpos
;
7412 current_buffer
= obuf
;
7418 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7422 redo_mouse_highlight ()
7424 if (!NILP (last_mouse_motion_frame
)
7425 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
7426 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
7427 last_mouse_motion_event
.x
,
7428 last_mouse_motion_event
.y
);
7433 /***********************************************************************
7435 ***********************************************************************/
7437 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
7438 struct glyph
**, int *, int *, int *));
7440 /* Tool-bar item index of the item on which a mouse button was pressed
7443 static int last_tool_bar_item
;
7446 /* Get information about the tool-bar item at position X/Y on frame F.
7447 Return in *GLYPH a pointer to the glyph of the tool-bar item in
7448 the current matrix of the tool-bar window of F, or NULL if not
7449 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
7450 item in F->tool_bar_items. Value is
7452 -1 if X/Y is not on a tool-bar item
7453 0 if X/Y is on the same item that was highlighted before.
7457 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
7460 struct glyph
**glyph
;
7461 int *hpos
, *vpos
, *prop_idx
;
7463 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7464 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7467 /* Find the glyph under X/Y. */
7468 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
, 0);
7472 /* Get the start of this tool-bar item's properties in
7473 f->tool_bar_items. */
7474 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
7477 /* Is mouse on the highlighted item? */
7478 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
7479 && *vpos
>= dpyinfo
->mouse_face_beg_row
7480 && *vpos
<= dpyinfo
->mouse_face_end_row
7481 && (*vpos
> dpyinfo
->mouse_face_beg_row
7482 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
7483 && (*vpos
< dpyinfo
->mouse_face_end_row
7484 || *hpos
< dpyinfo
->mouse_face_end_col
7485 || dpyinfo
->mouse_face_past_end
))
7492 /* Handle mouse button event on the tool-bar of frame F, at
7493 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
7497 x_handle_tool_bar_click (f
, button_event
)
7499 XButtonEvent
*button_event
;
7501 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7502 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7503 int hpos
, vpos
, prop_idx
;
7504 struct glyph
*glyph
;
7505 Lisp_Object enabled_p
;
7506 int x
= button_event
->x
;
7507 int y
= button_event
->y
;
7509 /* If not on the highlighted tool-bar item, return. */
7510 frame_to_window_pixel_xy (w
, &x
, &y
);
7511 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
7514 /* If item is disabled, do nothing. */
7515 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7516 if (NILP (enabled_p
))
7519 if (button_event
->type
== ButtonPress
)
7521 /* Show item in pressed state. */
7522 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
7523 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
7524 last_tool_bar_item
= prop_idx
;
7528 Lisp_Object key
, frame
;
7529 struct input_event event
;
7531 /* Show item in released state. */
7532 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
7533 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
7535 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
7537 XSETFRAME (frame
, f
);
7538 event
.kind
= TOOL_BAR_EVENT
;
7539 event
.frame_or_window
= frame
;
7541 kbd_buffer_store_event (&event
);
7543 event
.kind
= TOOL_BAR_EVENT
;
7544 event
.frame_or_window
= frame
;
7546 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
7547 button_event
->state
);
7548 kbd_buffer_store_event (&event
);
7549 last_tool_bar_item
= -1;
7554 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7555 tool-bar window-relative coordinates X/Y. Called from
7556 note_mouse_highlight. */
7559 note_tool_bar_highlight (f
, x
, y
)
7563 Lisp_Object window
= f
->tool_bar_window
;
7564 struct window
*w
= XWINDOW (window
);
7565 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7567 struct glyph
*glyph
;
7568 struct glyph_row
*row
;
7570 Lisp_Object enabled_p
;
7572 enum draw_glyphs_face draw
;
7573 int mouse_down_p
, rc
;
7575 /* Function note_mouse_highlight is called with negative x(y
7576 values when mouse moves outside of the frame. */
7577 if (x
<= 0 || y
<= 0)
7579 clear_mouse_face (dpyinfo
);
7583 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
7586 /* Not on tool-bar item. */
7587 clear_mouse_face (dpyinfo
);
7593 clear_mouse_face (dpyinfo
);
7595 /* Mouse is down, but on different tool-bar item? */
7596 mouse_down_p
= (dpyinfo
->grabbed
7597 && f
== last_mouse_frame
7598 && FRAME_LIVE_P (f
));
7600 && last_tool_bar_item
!= prop_idx
)
7603 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
7604 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
7606 /* If tool-bar item is not enabled, don't highlight it. */
7607 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7608 if (!NILP (enabled_p
))
7610 /* Compute the x-position of the glyph. In front and past the
7611 image is a space. We include this is the highlighted area. */
7612 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
7613 for (i
= x
= 0; i
< hpos
; ++i
)
7614 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
7616 /* Record this as the current active region. */
7617 dpyinfo
->mouse_face_beg_col
= hpos
;
7618 dpyinfo
->mouse_face_beg_row
= vpos
;
7619 dpyinfo
->mouse_face_beg_x
= x
;
7620 dpyinfo
->mouse_face_beg_y
= row
->y
;
7621 dpyinfo
->mouse_face_past_end
= 0;
7623 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
7624 dpyinfo
->mouse_face_end_row
= vpos
;
7625 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
7626 dpyinfo
->mouse_face_end_y
= row
->y
;
7627 dpyinfo
->mouse_face_window
= window
;
7628 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
7630 /* Display it as active. */
7631 show_mouse_face (dpyinfo
, draw
);
7632 dpyinfo
->mouse_face_image_state
= draw
;
7637 /* Set help_echo to a help string to display for this tool-bar item.
7638 XTread_socket does the rest. */
7639 help_echo_object
= help_echo_window
= Qnil
;
7641 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
7642 if (NILP (help_echo
))
7643 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
7648 /* Find the glyph matrix position of buffer position CHARPOS in window
7649 *W. HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7650 current glyphs must be up to date. If CHARPOS is above window
7651 start return (0, 0, 0, 0). If CHARPOS is after end of W, return end
7652 of last line in W. In the row containing CHARPOS, stop before glyphs
7653 having STOP as object. */
7655 #if 0 /* This is a version of fast_find_position that's more correct
7656 in the presence of hscrolling, for example. I didn't install
7657 it right away because the problem fixed is minor, it failed
7658 in 20.x as well, and I think it's too risky to install
7659 so near the release of 21.1. 2001-09-25 gerd. */
7662 fast_find_position (w
, charpos
, hpos
, vpos
, x
, y
, stop
)
7665 int *hpos
, *vpos
, *x
, *y
;
7668 struct glyph_row
*row
, *first
;
7669 struct glyph
*glyph
, *end
;
7670 int i
, past_end
= 0;
7672 first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7673 row
= row_containing_pos (w
, charpos
, first
, NULL
, 0);
7676 if (charpos
< MATRIX_ROW_START_CHARPOS (first
))
7678 *x
= *y
= *hpos
= *vpos
= 0;
7683 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
7690 *vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7692 glyph
= row
->glyphs
[TEXT_AREA
];
7693 end
= glyph
+ row
->used
[TEXT_AREA
];
7695 /* Skip over glyphs not having an object at the start of the row.
7696 These are special glyphs like truncation marks on terminal
7698 if (row
->displays_text_p
)
7700 && INTEGERP (glyph
->object
)
7701 && !EQ (stop
, glyph
->object
)
7702 && glyph
->charpos
< 0)
7704 *x
+= glyph
->pixel_width
;
7709 && !INTEGERP (glyph
->object
)
7710 && !EQ (stop
, glyph
->object
)
7711 && (!BUFFERP (glyph
->object
)
7712 || glyph
->charpos
< charpos
))
7714 *x
+= glyph
->pixel_width
;
7718 *hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
7725 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
, stop
)
7728 int *hpos
, *vpos
, *x
, *y
;
7733 int maybe_next_line_p
= 0;
7734 int line_start_position
;
7735 int yb
= window_text_bottom_y (w
);
7736 struct glyph_row
*row
, *best_row
;
7737 int row_vpos
, best_row_vpos
;
7740 row
= best_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7741 row_vpos
= best_row_vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7745 if (row
->used
[TEXT_AREA
])
7746 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
7748 line_start_position
= 0;
7750 if (line_start_position
> pos
)
7752 /* If the position sought is the end of the buffer,
7753 don't include the blank lines at the bottom of the window. */
7754 else if (line_start_position
== pos
7755 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
7757 maybe_next_line_p
= 1;
7760 else if (line_start_position
> 0)
7763 best_row_vpos
= row_vpos
;
7766 if (row
->y
+ row
->height
>= yb
)
7773 /* Find the right column within BEST_ROW. */
7775 current_x
= best_row
->x
;
7776 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
7778 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
7779 int charpos
= glyph
->charpos
;
7781 if (BUFFERP (glyph
->object
))
7786 *vpos
= best_row_vpos
;
7791 else if (charpos
> pos
)
7794 else if (EQ (glyph
->object
, stop
))
7799 current_x
+= glyph
->pixel_width
;
7802 /* If we're looking for the end of the buffer,
7803 and we didn't find it in the line we scanned,
7804 use the start of the following line. */
7805 if (maybe_next_line_p
)
7810 current_x
= best_row
->x
;
7813 *vpos
= best_row_vpos
;
7814 *hpos
= lastcol
+ 1;
7823 /* Find the position of the glyph for position POS in OBJECT in
7824 window W's current matrix, and return in *X, *Y the pixel
7825 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
7827 RIGHT_P non-zero means return the position of the right edge of the
7828 glyph, RIGHT_P zero means return the left edge position.
7830 If no glyph for POS exists in the matrix, return the position of
7831 the glyph with the next smaller position that is in the matrix, if
7832 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
7833 exists in the matrix, return the position of the glyph with the
7834 next larger position in OBJECT.
7836 Value is non-zero if a glyph was found. */
7839 fast_find_string_pos (w
, pos
, object
, hpos
, vpos
, x
, y
, right_p
)
7843 int *hpos
, *vpos
, *x
, *y
;
7846 int yb
= window_text_bottom_y (w
);
7847 struct glyph_row
*r
;
7848 struct glyph
*best_glyph
= NULL
;
7849 struct glyph_row
*best_row
= NULL
;
7852 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7853 r
->enabled_p
&& r
->y
< yb
;
7856 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7857 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
7860 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
7861 if (EQ (g
->object
, object
))
7863 if (g
->charpos
== pos
)
7870 else if (best_glyph
== NULL
7871 || ((abs (g
->charpos
- pos
)
7872 < abs (best_glyph
->charpos
- pos
))
7875 : g
->charpos
> pos
)))
7889 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
7893 *x
+= best_glyph
->pixel_width
;
7898 *vpos
= best_row
- w
->current_matrix
->rows
;
7901 return best_glyph
!= NULL
;
7905 /* Display the active region described by mouse_face_*
7906 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7909 show_mouse_face (dpyinfo
, draw
)
7910 struct x_display_info
*dpyinfo
;
7911 enum draw_glyphs_face draw
;
7913 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
7914 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7916 if (/* If window is in the process of being destroyed, don't bother
7918 w
->current_matrix
!= NULL
7919 /* Don't update mouse highlight if hidden */
7920 && (draw
!= DRAW_MOUSE_FACE
|| !dpyinfo
->mouse_face_hidden
)
7921 /* Recognize when we are called to operate on rows that don't exist
7922 anymore. This can happen when a window is split. */
7923 && dpyinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
7925 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
7926 struct glyph_row
*row
, *first
, *last
;
7928 first
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_beg_row
);
7929 last
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_end_row
);
7931 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
7933 int start_hpos
, end_hpos
, start_x
;
7935 /* For all but the first row, the highlight starts at column 0. */
7938 start_hpos
= dpyinfo
->mouse_face_beg_col
;
7939 start_x
= dpyinfo
->mouse_face_beg_x
;
7948 end_hpos
= dpyinfo
->mouse_face_end_col
;
7950 end_hpos
= row
->used
[TEXT_AREA
];
7952 if (end_hpos
> start_hpos
)
7954 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
7955 start_hpos
, end_hpos
, draw
, 0);
7958 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
7962 /* When we've written over the cursor, arrange for it to
7963 be displayed again. */
7964 if (phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
7965 x_display_cursor (w
, 1,
7966 w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
7967 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
7970 /* Change the mouse cursor. */
7971 if (draw
== DRAW_NORMAL_TEXT
)
7972 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7973 f
->output_data
.x
->text_cursor
);
7974 else if (draw
== DRAW_MOUSE_FACE
)
7975 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7976 f
->output_data
.x
->cross_cursor
);
7978 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7979 f
->output_data
.x
->nontext_cursor
);
7982 /* Clear out the mouse-highlighted active region.
7983 Redraw it un-highlighted first. Value is non-zero if mouse
7984 face was actually drawn unhighlighted. */
7987 clear_mouse_face (dpyinfo
)
7988 struct x_display_info
*dpyinfo
;
7992 if (!NILP (dpyinfo
->mouse_face_window
))
7994 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7998 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7999 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
8000 dpyinfo
->mouse_face_window
= Qnil
;
8001 dpyinfo
->mouse_face_overlay
= Qnil
;
8006 /* Clear any mouse-face on window W. This function is part of the
8007 redisplay interface, and is called from try_window_id and similar
8008 functions to ensure the mouse-highlight is off. */
8011 x_clear_mouse_face (w
)
8014 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
8018 XSETWINDOW (window
, w
);
8019 if (EQ (window
, dpyinfo
->mouse_face_window
))
8020 clear_mouse_face (dpyinfo
);
8025 /* Just discard the mouse face information for frame F, if any.
8026 This is used when the size of F is changed. */
8029 cancel_mouse_face (f
)
8033 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8035 window
= dpyinfo
->mouse_face_window
;
8036 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
8038 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
8039 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
8040 dpyinfo
->mouse_face_window
= Qnil
;
8045 static int glyph_rect
P_ ((struct frame
*f
, int, int, XRectangle
*));
8048 /* Try to determine frame pixel position and size of the glyph under
8049 frame pixel coordinates X/Y on frame F . Return the position and
8050 size in *RECT. Value is non-zero if we could compute these
8054 glyph_rect (f
, x
, y
, rect
)
8060 int part
, found
= 0;
8062 window
= window_from_coordinates (f
, x
, y
, &part
, 0);
8065 struct window
*w
= XWINDOW (window
);
8066 struct glyph_row
*r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
8067 struct glyph_row
*end
= r
+ w
->current_matrix
->nrows
- 1;
8069 frame_to_window_pixel_xy (w
, &x
, &y
);
8071 for (; !found
&& r
< end
&& r
->enabled_p
; ++r
)
8074 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
8075 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
8078 for (gx
= r
->x
; !found
&& g
< end
; gx
+= g
->pixel_width
, ++g
)
8081 rect
->width
= g
->pixel_width
;
8082 rect
->height
= r
->height
;
8083 rect
->x
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
8084 rect
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
8094 /* Return the current position of the mouse.
8095 *FP should be a frame which indicates which display to ask about.
8097 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
8098 and *PART to the frame, window, and scroll bar part that the mouse
8099 is over. Set *X and *Y to the portion and whole of the mouse's
8100 position on the scroll bar.
8102 If the mouse movement started elsewhere, set *FP to the frame the
8103 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
8106 Set *TIME to the server time-stamp for the time at which the mouse
8107 was at this position.
8109 Don't store anything if we don't have a valid set of values to report.
8111 This clears the mouse_moved flag, so we can wait for the next mouse
8115 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
8118 Lisp_Object
*bar_window
;
8119 enum scroll_bar_part
*part
;
8121 unsigned long *time
;
8127 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
8128 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
8134 Window dummy_window
;
8137 Lisp_Object frame
, tail
;
8139 /* Clear the mouse-moved flag for every frame on this display. */
8140 FOR_EACH_FRAME (tail
, frame
)
8141 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
8142 XFRAME (frame
)->mouse_moved
= 0;
8144 last_mouse_scroll_bar
= Qnil
;
8146 /* Figure out which root window we're on. */
8147 XQueryPointer (FRAME_X_DISPLAY (*fp
),
8148 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
8150 /* The root window which contains the pointer. */
8153 /* Trash which we can't trust if the pointer is on
8154 a different screen. */
8157 /* The position on that root window. */
8160 /* More trash we can't trust. */
8163 /* Modifier keys and pointer buttons, about which
8165 (unsigned int *) &dummy
);
8167 /* Now we have a position on the root; find the innermost window
8168 containing the pointer. */
8172 int parent_x
= 0, parent_y
= 0;
8177 /* XTranslateCoordinates can get errors if the window
8178 structure is changing at the same time this function
8179 is running. So at least we must not crash from them. */
8181 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
8183 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
8184 && FRAME_LIVE_P (last_mouse_frame
))
8186 /* If mouse was grabbed on a frame, give coords for that frame
8187 even if the mouse is now outside it. */
8188 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
8190 /* From-window, to-window. */
8191 root
, FRAME_X_WINDOW (last_mouse_frame
),
8193 /* From-position, to-position. */
8194 root_x
, root_y
, &win_x
, &win_y
,
8198 f1
= last_mouse_frame
;
8204 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
8206 /* From-window, to-window. */
8209 /* From-position, to-position. */
8210 root_x
, root_y
, &win_x
, &win_y
,
8215 if (child
== None
|| child
== win
)
8223 /* Now we know that:
8224 win is the innermost window containing the pointer
8225 (XTC says it has no child containing the pointer),
8226 win_x and win_y are the pointer's position in it
8227 (XTC did this the last time through), and
8228 parent_x and parent_y are the pointer's position in win's parent.
8229 (They are what win_x and win_y were when win was child.
8230 If win is the root window, it has no parent, and
8231 parent_{x,y} are invalid, but that's okay, because we'll
8232 never use them in that case.) */
8234 /* Is win one of our frames? */
8235 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
8237 #ifdef USE_X_TOOLKIT
8238 /* If we end up with the menu bar window, say it's not
8241 && f1
->output_data
.x
->menubar_widget
8242 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
8244 #endif /* USE_X_TOOLKIT */
8247 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
8250 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
8252 /* If not, is it one of our scroll bars? */
8255 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
8259 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8265 if (f1
== 0 && insist
> 0)
8266 f1
= SELECTED_FRAME ();
8270 /* Ok, we found a frame. Store all the values.
8271 last_mouse_glyph is a rectangle used to reduce the
8272 generation of mouse events. To not miss any motion
8273 events, we must divide the frame into rectangles of the
8274 size of the smallest character that could be displayed
8275 on it, i.e. into the same rectangles that matrices on
8276 the frame are divided into. */
8278 int width
, height
, gx
, gy
;
8281 if (glyph_rect (f1
, win_x
, win_y
, &rect
))
8282 last_mouse_glyph
= rect
;
8285 width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
8286 height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
8290 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
8291 round down even for negative values. */
8296 gx
= (gx
+ width
- 1) / width
* width
;
8297 gy
= (gy
+ height
- 1) / height
* height
;
8299 last_mouse_glyph
.width
= width
;
8300 last_mouse_glyph
.height
= height
;
8301 last_mouse_glyph
.x
= gx
;
8302 last_mouse_glyph
.y
= gy
;
8308 XSETINT (*x
, win_x
);
8309 XSETINT (*y
, win_y
);
8310 *time
= last_mouse_movement_time
;
8319 #ifdef USE_X_TOOLKIT
8321 /* Atimer callback function for TIMER. Called every 0.1s to process
8322 Xt timeouts, if needed. We must avoid calling XtAppPending as
8323 much as possible because that function does an implicit XFlush
8324 that slows us down. */
8327 x_process_timeouts (timer
)
8328 struct atimer
*timer
;
8330 if (toolkit_scroll_bar_interaction
|| popup_activated_flag
)
8333 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
8334 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
8339 #endif /* USE_X_TOOLKIT */
8342 /* Scroll bar support. */
8344 /* Given an X window ID, find the struct scroll_bar which manages it.
8345 This can be called in GC, so we have to make sure to strip off mark
8348 static struct scroll_bar
*
8349 x_window_to_scroll_bar (window_id
)
8354 for (tail
= Vframe_list
;
8355 XGCTYPE (tail
) == Lisp_Cons
;
8358 Lisp_Object frame
, bar
, condemned
;
8360 frame
= XCAR (tail
);
8361 /* All elements of Vframe_list should be frames. */
8362 if (! GC_FRAMEP (frame
))
8365 /* Scan this frame's scroll bar list for a scroll bar with the
8367 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
8368 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
8369 /* This trick allows us to search both the ordinary and
8370 condemned scroll bar lists with one loop. */
8371 ! GC_NILP (bar
) || (bar
= condemned
,
8374 bar
= XSCROLL_BAR (bar
)->next
)
8375 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
8376 return XSCROLL_BAR (bar
);
8383 #if defined USE_LUCID
8385 /* Return the Lucid menu bar WINDOW is part of. Return null
8386 if WINDOW is not part of a menu bar. */
8389 x_window_to_menu_bar (window
)
8394 for (tail
= Vframe_list
;
8395 XGCTYPE (tail
) == Lisp_Cons
;
8398 Lisp_Object frame
= XCAR (tail
);
8399 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
8401 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
8408 #endif /* USE_LUCID */
8411 /************************************************************************
8413 ************************************************************************/
8415 #ifdef USE_TOOLKIT_SCROLL_BARS
8417 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
8418 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
8419 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
8420 struct scroll_bar
*));
8421 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
8425 /* Id of action hook installed for scroll bars. */
8427 static XtActionHookId action_hook_id
;
8429 /* Lisp window being scrolled. Set when starting to interact with
8430 a toolkit scroll bar, reset to nil when ending the interaction. */
8432 static Lisp_Object window_being_scrolled
;
8434 /* Last scroll bar part sent in xm_scroll_callback. */
8436 static int last_scroll_bar_part
;
8438 /* Whether this is an Xaw with arrow-scrollbars. This should imply
8439 that movements of 1/20 of the screen size are mapped to up/down. */
8441 static Boolean xaw3d_arrow_scroll
;
8443 /* Whether the drag scrolling maintains the mouse at the top of the
8444 thumb. If not, resizing the thumb needs to be done more carefully
8445 to avoid jerkyness. */
8447 static Boolean xaw3d_pick_top
;
8450 /* Action hook installed via XtAppAddActionHook when toolkit scroll
8451 bars are used.. The hook is responsible for detecting when
8452 the user ends an interaction with the scroll bar, and generates
8453 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
8456 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
8459 XtPointer client_data
;
8463 Cardinal
*num_params
;
8469 scroll_bar_p
= XmIsScrollBar (widget
);
8470 end_action
= "Release";
8471 #else /* !USE_MOTIF i.e. use Xaw */
8472 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
8473 end_action
= "EndScroll";
8474 #endif /* USE_MOTIF */
8477 && strcmp (action_name
, end_action
) == 0
8478 && WINDOWP (window_being_scrolled
))
8482 x_send_scroll_bar_event (window_being_scrolled
,
8483 scroll_bar_end_scroll
, 0, 0);
8484 w
= XWINDOW (window_being_scrolled
);
8485 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
8486 window_being_scrolled
= Qnil
;
8487 last_scroll_bar_part
= -1;
8489 /* Xt timeouts no longer needed. */
8490 toolkit_scroll_bar_interaction
= 0;
8494 /* A vector of windows used for communication between
8495 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
8497 static struct window
**scroll_bar_windows
;
8498 static int scroll_bar_windows_size
;
8501 /* Send a client message with message type Xatom_Scrollbar for a
8502 scroll action to the frame of WINDOW. PART is a value identifying
8503 the part of the scroll bar that was clicked on. PORTION is the
8504 amount to scroll of a whole of WHOLE. */
8507 x_send_scroll_bar_event (window
, part
, portion
, whole
)
8509 int part
, portion
, whole
;
8512 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
8513 struct window
*w
= XWINDOW (window
);
8514 struct frame
*f
= XFRAME (w
->frame
);
8519 /* Construct a ClientMessage event to send to the frame. */
8520 ev
->type
= ClientMessage
;
8521 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
8522 ev
->display
= FRAME_X_DISPLAY (f
);
8523 ev
->window
= FRAME_X_WINDOW (f
);
8526 /* We can only transfer 32 bits in the XClientMessageEvent, which is
8527 not enough to store a pointer or Lisp_Object on a 64 bit system.
8528 So, store the window in scroll_bar_windows and pass the index
8529 into that array in the event. */
8530 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
8531 if (scroll_bar_windows
[i
] == NULL
)
8534 if (i
== scroll_bar_windows_size
)
8536 int new_size
= max (10, 2 * scroll_bar_windows_size
);
8537 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
8538 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
8540 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
8542 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
8543 scroll_bar_windows_size
= new_size
;
8546 scroll_bar_windows
[i
] = w
;
8547 ev
->data
.l
[0] = (long) i
;
8548 ev
->data
.l
[1] = (long) part
;
8549 ev
->data
.l
[2] = (long) 0;
8550 ev
->data
.l
[3] = (long) portion
;
8551 ev
->data
.l
[4] = (long) whole
;
8553 /* Make Xt timeouts work while the scroll bar is active. */
8554 toolkit_scroll_bar_interaction
= 1;
8556 /* Setting the event mask to zero means that the message will
8557 be sent to the client that created the window, and if that
8558 window no longer exists, no event will be sent. */
8559 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
8564 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
8568 x_scroll_bar_to_input_event (event
, ievent
)
8570 struct input_event
*ievent
;
8572 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
8577 w
= scroll_bar_windows
[ev
->data
.l
[0]];
8578 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
8580 XSETWINDOW (window
, w
);
8581 f
= XFRAME (w
->frame
);
8583 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
8584 ievent
->frame_or_window
= window
;
8586 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
8587 ievent
->part
= ev
->data
.l
[1];
8588 ievent
->code
= ev
->data
.l
[2];
8589 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
8590 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
8591 ievent
->modifiers
= 0;
8597 /* Minimum and maximum values used for Motif scroll bars. */
8600 #define XM_SB_MAX 10000000
8601 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
8604 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
8605 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
8606 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
8609 xm_scroll_callback (widget
, client_data
, call_data
)
8611 XtPointer client_data
, call_data
;
8613 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8614 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
8615 int part
= -1, whole
= 0, portion
= 0;
8619 case XmCR_DECREMENT
:
8620 bar
->dragging
= Qnil
;
8621 part
= scroll_bar_up_arrow
;
8624 case XmCR_INCREMENT
:
8625 bar
->dragging
= Qnil
;
8626 part
= scroll_bar_down_arrow
;
8629 case XmCR_PAGE_DECREMENT
:
8630 bar
->dragging
= Qnil
;
8631 part
= scroll_bar_above_handle
;
8634 case XmCR_PAGE_INCREMENT
:
8635 bar
->dragging
= Qnil
;
8636 part
= scroll_bar_below_handle
;
8640 bar
->dragging
= Qnil
;
8641 part
= scroll_bar_to_top
;
8644 case XmCR_TO_BOTTOM
:
8645 bar
->dragging
= Qnil
;
8646 part
= scroll_bar_to_bottom
;
8652 int dragging_down_p
= (INTEGERP (bar
->dragging
)
8653 && XINT (bar
->dragging
) <= cs
->value
);
8655 /* Get the slider size. */
8657 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
8660 whole
= XM_SB_RANGE
- slider_size
;
8661 portion
= min (cs
->value
- XM_SB_MIN
, whole
);
8662 part
= scroll_bar_handle
;
8663 bar
->dragging
= make_number (cs
->value
);
8667 case XmCR_VALUE_CHANGED
:
8673 window_being_scrolled
= bar
->window
;
8674 last_scroll_bar_part
= part
;
8675 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
8680 #else /* !USE_MOTIF, i.e. Xaw. */
8683 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
8684 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
8685 scroll bar struct. CALL_DATA is a pointer to a float saying where
8689 xaw_jump_callback (widget
, client_data
, call_data
)
8691 XtPointer client_data
, call_data
;
8693 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8694 float top
= *(float *) call_data
;
8696 int whole
, portion
, height
;
8699 /* Get the size of the thumb, a value between 0 and 1. */
8701 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
8705 portion
= shown
< 1 ? top
* whole
: 0;
8707 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
8708 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
8709 the bottom, so we force the scrolling whenever we see that we're
8710 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
8711 we try to ensure that we always stay two pixels away from the
8713 part
= scroll_bar_down_arrow
;
8715 part
= scroll_bar_handle
;
8717 window_being_scrolled
= bar
->window
;
8718 bar
->dragging
= make_number (portion
);
8719 last_scroll_bar_part
= part
;
8720 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
8724 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
8725 i.e. line or page up or down. WIDGET is the Xaw scroll bar
8726 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
8727 the scroll bar. CALL_DATA is an integer specifying the action that
8728 has taken place. It's magnitude is in the range 0..height of the
8729 scroll bar. Negative values mean scroll towards buffer start.
8730 Values < height of scroll bar mean line-wise movement. */
8733 xaw_scroll_callback (widget
, client_data
, call_data
)
8735 XtPointer client_data
, call_data
;
8737 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8738 int position
= (int) call_data
;
8742 /* Get the height of the scroll bar. */
8744 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
8747 if (abs (position
) >= height
)
8748 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
8750 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
8751 it maps line-movement to call_data = max(5, height/20). */
8752 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
8753 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
8755 part
= scroll_bar_move_ratio
;
8757 window_being_scrolled
= bar
->window
;
8758 bar
->dragging
= Qnil
;
8759 last_scroll_bar_part
= part
;
8760 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
8764 #endif /* not USE_MOTIF */
8767 /* Create the widget for scroll bar BAR on frame F. Record the widget
8768 and X window of the scroll bar in BAR. */
8771 x_create_toolkit_scroll_bar (f
, bar
)
8773 struct scroll_bar
*bar
;
8779 char *scroll_bar_name
= "verticalScrollBar";
8780 unsigned long pixel
;
8785 /* Set resources. Create the widget. */
8786 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8787 XtSetArg (av
[ac
], XmNminimum
, XM_SB_MIN
); ++ac
;
8788 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
8789 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
8790 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
8791 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
8792 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
8794 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8797 XtSetArg (av
[ac
], XmNforeground
, pixel
);
8801 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8804 XtSetArg (av
[ac
], XmNbackground
, pixel
);
8808 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
8809 scroll_bar_name
, av
, ac
);
8811 /* Add one callback for everything that can happen. */
8812 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
8814 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
8816 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
8818 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
8820 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
8822 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
8824 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
8827 /* Realize the widget. Only after that is the X window created. */
8828 XtRealizeWidget (widget
);
8830 /* Set the cursor to an arrow. I didn't find a resource to do that.
8831 And I'm wondering why it hasn't an arrow cursor by default. */
8832 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
8833 f
->output_data
.x
->nontext_cursor
);
8835 #else /* !USE_MOTIF i.e. use Xaw */
8837 /* Set resources. Create the widget. The background of the
8838 Xaw3d scroll bar widget is a little bit light for my taste.
8839 We don't alter it here to let users change it according
8840 to their taste with `emacs*verticalScrollBar.background: xxx'. */
8841 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8842 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
8843 /* For smoother scrolling with Xaw3d -sm */
8844 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
8846 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8849 XtSetArg (av
[ac
], XtNforeground
, pixel
);
8853 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8856 XtSetArg (av
[ac
], XtNbackground
, pixel
);
8860 /* Top/bottom shadow colors. */
8862 /* Allocate them, if necessary. */
8863 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
8865 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8866 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
8867 &pixel
, 1.2, 0x8000))
8869 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
8871 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
8873 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8874 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
8875 &pixel
, 0.6, 0x4000))
8877 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
8880 /* Tell the toolkit about them. */
8881 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
8882 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
8883 /* We tried to allocate a color for the top/bottom shadow, and
8884 failed, so tell Xaw3d to use dithering instead. */
8886 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
8890 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
8891 be more consistent with other emacs 3d colors, and since Xaw3d is
8892 not good at dealing with allocation failure. */
8894 /* This tells Xaw3d to use real colors instead of dithering for
8896 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
8899 /* Specify the colors. */
8900 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
8903 XtSetArg (av
[ac
], "topShadowPixel", pixel
);
8906 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
8909 XtSetArg (av
[ac
], "bottomShadowPixel", pixel
);
8914 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
8915 f
->output_data
.x
->edit_widget
, av
, ac
);
8919 char *val
= initial
;
8920 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
8921 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
8923 { /* ARROW_SCROLL */
8924 xaw3d_arrow_scroll
= True
;
8925 /* Isn't that just a personal preference ? -sm */
8926 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
8930 /* Define callbacks. */
8931 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
8932 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
8935 /* Realize the widget. Only after that is the X window created. */
8936 XtRealizeWidget (widget
);
8938 #endif /* !USE_MOTIF */
8940 /* Install an action hook that let's us detect when the user
8941 finishes interacting with a scroll bar. */
8942 if (action_hook_id
== 0)
8943 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
8945 /* Remember X window and widget in the scroll bar vector. */
8946 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
8947 xwindow
= XtWindow (widget
);
8948 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
8954 /* Set the thumb size and position of scroll bar BAR. We are currently
8955 displaying PORTION out of a whole WHOLE, and our position POSITION. */
8958 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
8959 struct scroll_bar
*bar
;
8960 int portion
, position
, whole
;
8962 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8963 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
8970 /* We use an estimate of 30 chars per line rather than the real
8971 `portion' value. This has the disadvantage that the thumb size
8972 is not very representative, but it makes our life a lot easier.
8973 Otherwise, we have to constantly adjust the thumb size, which
8974 we can't always do quickly enough: while dragging, the size of
8975 the thumb might prevent the user from dragging the thumb all the
8976 way to the end. but Motif and some versions of Xaw3d don't allow
8977 updating the thumb size while dragging. Also, even if we can update
8978 its size, the update will often happen too late.
8979 If you don't believe it, check out revision 1.650 of xterm.c to see
8980 what hoops we were going through and the still poor behavior we got. */
8981 portion
= XFASTINT (XWINDOW (bar
->window
)->height
) * 30;
8982 /* When the thumb is at the bottom, position == whole.
8983 So we need to increase `whole' to make space for the thumb. */
8990 top
= (float) position
/ whole
;
8991 shown
= (float) portion
/ whole
;
8994 if (NILP (bar
->dragging
))
8998 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
8999 is the scroll bar's maximum and MIN is the scroll bar's minimum
9001 size
= shown
* XM_SB_RANGE
;
9002 size
= min (size
, XM_SB_RANGE
);
9003 size
= max (size
, 1);
9005 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
9006 value
= top
* XM_SB_RANGE
;
9007 value
= min (value
, XM_SB_MAX
- size
);
9008 value
= max (value
, XM_SB_MIN
);
9010 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
9012 #else /* !USE_MOTIF i.e. use Xaw */
9018 top
= (float) position
/ whole
;
9019 shown
= (float) portion
/ whole
;
9023 float old_top
, old_shown
;
9025 XtVaGetValues (widget
,
9026 XtNtopOfThumb
, &old_top
,
9027 XtNshown
, &old_shown
,
9031 /* Massage the top+shown values. */
9032 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
9033 top
= max (0, min (1, top
));
9036 /* Keep two pixels available for moving the thumb down. */
9037 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
9039 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
9040 check that your system's configuration file contains a define
9041 for `NARROWPROTO'. See s/freebsd.h for an example. */
9042 if (top
!= old_top
|| shown
!= old_shown
)
9044 if (NILP (bar
->dragging
))
9045 XawScrollbarSetThumb (widget
, top
, shown
);
9049 ScrollbarWidget sb
= (ScrollbarWidget
) widget
;
9050 int scroll_mode
= 0;
9052 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
9053 if (xaw3d_arrow_scroll
)
9055 /* Xaw3d stupidly ignores resize requests while dragging
9056 so we have to make it believe it's not in dragging mode. */
9057 scroll_mode
= sb
->scrollbar
.scroll_mode
;
9058 if (scroll_mode
== 2)
9059 sb
->scrollbar
.scroll_mode
= 0;
9062 /* Try to make the scrolling a tad smoother. */
9063 if (!xaw3d_pick_top
)
9064 shown
= min (shown
, old_shown
);
9066 XawScrollbarSetThumb (widget
, top
, shown
);
9069 if (xaw3d_arrow_scroll
&& scroll_mode
== 2)
9070 sb
->scrollbar
.scroll_mode
= scroll_mode
;
9075 #endif /* !USE_MOTIF */
9080 #endif /* USE_TOOLKIT_SCROLL_BARS */
9084 /************************************************************************
9085 Scroll bars, general
9086 ************************************************************************/
9088 /* Create a scroll bar and return the scroll bar vector for it. W is
9089 the Emacs window on which to create the scroll bar. TOP, LEFT,
9090 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
9093 static struct scroll_bar
*
9094 x_scroll_bar_create (w
, top
, left
, width
, height
)
9096 int top
, left
, width
, height
;
9098 struct frame
*f
= XFRAME (w
->frame
);
9099 struct scroll_bar
*bar
9100 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
9104 #ifdef USE_TOOLKIT_SCROLL_BARS
9105 x_create_toolkit_scroll_bar (f
, bar
);
9106 #else /* not USE_TOOLKIT_SCROLL_BARS */
9108 XSetWindowAttributes a
;
9112 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
9113 if (a
.background_pixel
== -1)
9114 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
9116 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
9117 | ButtonMotionMask
| PointerMotionHintMask
9119 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
9121 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
9123 /* Clear the area of W that will serve as a scroll bar. This is
9124 for the case that a window has been split horizontally. In
9125 this case, no clear_frame is generated to reduce flickering. */
9126 if (width
> 0 && height
> 0)
9127 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9129 window_box_height (w
), False
);
9131 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9132 /* Position and size of scroll bar. */
9133 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9135 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
9137 /* Border width, depth, class, and visual. */
9144 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
9146 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9148 XSETWINDOW (bar
->window
, w
);
9149 XSETINT (bar
->top
, top
);
9150 XSETINT (bar
->left
, left
);
9151 XSETINT (bar
->width
, width
);
9152 XSETINT (bar
->height
, height
);
9153 XSETINT (bar
->start
, 0);
9154 XSETINT (bar
->end
, 0);
9155 bar
->dragging
= Qnil
;
9157 /* Add bar to its frame's list of scroll bars. */
9158 bar
->next
= FRAME_SCROLL_BARS (f
);
9160 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
9161 if (!NILP (bar
->next
))
9162 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
9164 /* Map the window/widget. */
9165 #ifdef USE_TOOLKIT_SCROLL_BARS
9167 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
9168 XtConfigureWidget (scroll_bar
,
9169 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9171 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
9172 max (height
, 1), 0);
9173 XtMapWidget (scroll_bar
);
9175 #else /* not USE_TOOLKIT_SCROLL_BARS */
9176 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
9177 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9184 /* Draw BAR's handle in the proper position.
9186 If the handle is already drawn from START to END, don't bother
9187 redrawing it, unless REBUILD is non-zero; in that case, always
9188 redraw it. (REBUILD is handy for drawing the handle after expose
9191 Normally, we want to constrain the start and end of the handle to
9192 fit inside its rectangle, but if the user is dragging the scroll
9193 bar handle, we want to let them drag it down all the way, so that
9194 the bar's top is as far down as it goes; otherwise, there's no way
9195 to move to the very end of the buffer. */
9197 #ifndef USE_TOOLKIT_SCROLL_BARS
9200 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
9201 struct scroll_bar
*bar
;
9205 int dragging
= ! NILP (bar
->dragging
);
9206 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9207 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9208 GC gc
= f
->output_data
.x
->normal_gc
;
9210 /* If the display is already accurate, do nothing. */
9212 && start
== XINT (bar
->start
)
9213 && end
== XINT (bar
->end
))
9219 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
9220 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9221 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9223 /* Make sure the values are reasonable, and try to preserve
9224 the distance between start and end. */
9226 int length
= end
- start
;
9230 else if (start
> top_range
)
9232 end
= start
+ length
;
9236 else if (end
> top_range
&& ! dragging
)
9240 /* Store the adjusted setting in the scroll bar. */
9241 XSETINT (bar
->start
, start
);
9242 XSETINT (bar
->end
, end
);
9244 /* Clip the end position, just for display. */
9245 if (end
> top_range
)
9248 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
9249 below top positions, to make sure the handle is always at least
9250 that many pixels tall. */
9251 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
9253 /* Draw the empty space above the handle. Note that we can't clear
9254 zero-height areas; that means "clear to end of window." */
9256 x_clear_area (FRAME_X_DISPLAY (f
), w
,
9257 /* x, y, width, height, and exposures. */
9258 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
9259 VERTICAL_SCROLL_BAR_TOP_BORDER
,
9260 inside_width
, start
,
9263 /* Change to proper foreground color if one is specified. */
9264 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9265 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
9266 f
->output_data
.x
->scroll_bar_foreground_pixel
);
9268 /* Draw the handle itself. */
9269 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
9270 /* x, y, width, height */
9271 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
9272 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
9273 inside_width
, end
- start
);
9275 /* Restore the foreground color of the GC if we changed it above. */
9276 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9277 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
9278 f
->output_data
.x
->foreground_pixel
);
9280 /* Draw the empty space below the handle. Note that we can't
9281 clear zero-height areas; that means "clear to end of window." */
9282 if (end
< inside_height
)
9283 x_clear_area (FRAME_X_DISPLAY (f
), w
,
9284 /* x, y, width, height, and exposures. */
9285 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
9286 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
9287 inside_width
, inside_height
- end
,
9295 #endif /* !USE_TOOLKIT_SCROLL_BARS */
9297 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
9301 x_scroll_bar_remove (bar
)
9302 struct scroll_bar
*bar
;
9304 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9307 #ifdef USE_TOOLKIT_SCROLL_BARS
9308 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
9310 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
9313 /* Disassociate this scroll bar from its window. */
9314 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
9320 /* Set the handle of the vertical scroll bar for WINDOW to indicate
9321 that we are displaying PORTION characters out of a total of WHOLE
9322 characters, starting at POSITION. If WINDOW has no scroll bar,
9326 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
9328 int portion
, whole
, position
;
9330 struct frame
*f
= XFRAME (w
->frame
);
9331 struct scroll_bar
*bar
;
9332 int top
, height
, left
, sb_left
, width
, sb_width
;
9333 int window_x
, window_y
, window_width
, window_height
;
9335 /* Get window dimensions. */
9336 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
9338 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
9339 height
= window_height
;
9341 /* Compute the left edge of the scroll bar area. */
9342 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9343 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
9345 left
= XFASTINT (w
->left
);
9346 left
*= CANON_X_UNIT (f
);
9347 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
9349 /* Compute the width of the scroll bar which might be less than
9350 the width of the area reserved for the scroll bar. */
9351 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
9352 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
9356 /* Compute the left edge of the scroll bar. */
9357 #ifdef USE_TOOLKIT_SCROLL_BARS
9358 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9359 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
9361 sb_left
= left
+ (width
- sb_width
) / 2;
9363 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9364 sb_left
= left
+ width
- sb_width
;
9369 /* Does the scroll bar exist yet? */
9370 if (NILP (w
->vertical_scroll_bar
))
9372 if (width
> 0 && height
> 0)
9375 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9376 left
, top
, width
, height
, False
);
9380 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
9384 /* It may just need to be moved and resized. */
9385 unsigned int mask
= 0;
9387 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
9391 if (sb_left
!= XINT (bar
->left
))
9393 if (top
!= XINT (bar
->top
))
9395 if (sb_width
!= XINT (bar
->width
))
9397 if (height
!= XINT (bar
->height
))
9400 #ifdef USE_TOOLKIT_SCROLL_BARS
9402 /* Since toolkit scroll bars are smaller than the space reserved
9403 for them on the frame, we have to clear "under" them. */
9404 if (width
> 0 && height
> 0)
9405 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9406 left
, top
, width
, height
, False
);
9408 /* Move/size the scroll bar widget. */
9410 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
9411 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9413 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
9414 max (height
, 1), 0);
9416 #else /* not USE_TOOLKIT_SCROLL_BARS */
9418 /* Clear areas not covered by the scroll bar because of
9419 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
9420 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
9422 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9423 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9425 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9426 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9427 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9431 /* Clear areas not covered by the scroll bar because it's not as
9432 wide as the area reserved for it. This makes sure a
9433 previous mode line display is cleared after C-x 2 C-x 1, for
9436 int area_width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
9437 int rest
= area_width
- sb_width
;
9438 if (rest
> 0 && height
> 0)
9440 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
9441 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9442 left
+ area_width
- rest
, top
,
9443 rest
, height
, False
);
9445 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9446 left
, top
, rest
, height
, False
);
9450 /* Move/size the scroll bar window. */
9455 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
9457 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
9459 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
9463 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9465 /* Remember new settings. */
9466 XSETINT (bar
->left
, sb_left
);
9467 XSETINT (bar
->top
, top
);
9468 XSETINT (bar
->width
, sb_width
);
9469 XSETINT (bar
->height
, height
);
9474 #ifdef USE_TOOLKIT_SCROLL_BARS
9475 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
9476 #else /* not USE_TOOLKIT_SCROLL_BARS */
9477 /* Set the scroll bar's current state, unless we're currently being
9479 if (NILP (bar
->dragging
))
9481 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
9484 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
9487 int start
= ((double) position
* top_range
) / whole
;
9488 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
9489 x_scroll_bar_set_handle (bar
, start
, end
, 0);
9492 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9494 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
9498 /* The following three hooks are used when we're doing a thorough
9499 redisplay of the frame. We don't explicitly know which scroll bars
9500 are going to be deleted, because keeping track of when windows go
9501 away is a real pain - "Can you say set-window-configuration, boys
9502 and girls?" Instead, we just assert at the beginning of redisplay
9503 that *all* scroll bars are to be removed, and then save a scroll bar
9504 from the fiery pit when we actually redisplay its window. */
9506 /* Arrange for all scroll bars on FRAME to be removed at the next call
9507 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
9508 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
9511 XTcondemn_scroll_bars (frame
)
9514 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
9515 while (! NILP (FRAME_SCROLL_BARS (frame
)))
9518 bar
= FRAME_SCROLL_BARS (frame
);
9519 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
9520 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
9521 XSCROLL_BAR (bar
)->prev
= Qnil
;
9522 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
9523 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
9524 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
9529 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
9530 Note that WINDOW isn't necessarily condemned at all. */
9533 XTredeem_scroll_bar (window
)
9534 struct window
*window
;
9536 struct scroll_bar
*bar
;
9539 /* We can't redeem this window's scroll bar if it doesn't have one. */
9540 if (NILP (window
->vertical_scroll_bar
))
9543 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
9545 /* Unlink it from the condemned list. */
9546 f
= XFRAME (WINDOW_FRAME (window
));
9547 if (NILP (bar
->prev
))
9549 /* If the prev pointer is nil, it must be the first in one of
9551 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
9552 /* It's not condemned. Everything's fine. */
9554 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
9555 window
->vertical_scroll_bar
))
9556 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
9558 /* If its prev pointer is nil, it must be at the front of
9559 one or the other! */
9563 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
9565 if (! NILP (bar
->next
))
9566 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
9568 bar
->next
= FRAME_SCROLL_BARS (f
);
9570 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
9571 if (! NILP (bar
->next
))
9572 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
9575 /* Remove all scroll bars on FRAME that haven't been saved since the
9576 last call to `*condemn_scroll_bars_hook'. */
9579 XTjudge_scroll_bars (f
)
9582 Lisp_Object bar
, next
;
9584 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
9586 /* Clear out the condemned list now so we won't try to process any
9587 more events on the hapless scroll bars. */
9588 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
9590 for (; ! NILP (bar
); bar
= next
)
9592 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
9594 x_scroll_bar_remove (b
);
9597 b
->next
= b
->prev
= Qnil
;
9600 /* Now there should be no references to the condemned scroll bars,
9601 and they should get garbage-collected. */
9605 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
9606 is a no-op when using toolkit scroll bars.
9608 This may be called from a signal handler, so we have to ignore GC
9612 x_scroll_bar_expose (bar
, event
)
9613 struct scroll_bar
*bar
;
9616 #ifndef USE_TOOLKIT_SCROLL_BARS
9618 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9619 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9620 GC gc
= f
->output_data
.x
->normal_gc
;
9621 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
9625 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
9627 /* Draw a one-pixel border just inside the edges of the scroll bar. */
9628 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
9630 /* x, y, width, height */
9632 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
9633 XINT (bar
->height
) - 1);
9637 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9640 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
9641 is set to something other than NO_EVENT, it is enqueued.
9643 This may be called from a signal handler, so we have to ignore GC
9646 #ifndef USE_TOOLKIT_SCROLL_BARS
9649 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
9650 struct scroll_bar
*bar
;
9652 struct input_event
*emacs_event
;
9654 if (! GC_WINDOWP (bar
->window
))
9657 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
9658 emacs_event
->code
= event
->xbutton
.button
- Button1
;
9659 emacs_event
->modifiers
9660 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
9661 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
9662 event
->xbutton
.state
)
9663 | (event
->type
== ButtonRelease
9666 emacs_event
->frame_or_window
= bar
->window
;
9667 emacs_event
->arg
= Qnil
;
9668 emacs_event
->timestamp
= event
->xbutton
.time
;
9671 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9673 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9676 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9677 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
9680 if (y
> top_range
) y
= top_range
;
9682 if (y
< XINT (bar
->start
))
9683 emacs_event
->part
= scroll_bar_above_handle
;
9684 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
9685 emacs_event
->part
= scroll_bar_handle
;
9687 emacs_event
->part
= scroll_bar_below_handle
;
9689 /* Just because the user has clicked on the handle doesn't mean
9690 they want to drag it. Lisp code needs to be able to decide
9691 whether or not we're dragging. */
9693 /* If the user has just clicked on the handle, record where they're
9695 if (event
->type
== ButtonPress
9696 && emacs_event
->part
== scroll_bar_handle
)
9697 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
9700 /* If the user has released the handle, set it to its final position. */
9701 if (event
->type
== ButtonRelease
9702 && ! NILP (bar
->dragging
))
9704 int new_start
= y
- XINT (bar
->dragging
);
9705 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
9707 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
9708 bar
->dragging
= Qnil
;
9711 /* Same deal here as the other #if 0. */
9713 /* Clicks on the handle are always reported as occurring at the top of
9715 if (emacs_event
->part
== scroll_bar_handle
)
9716 emacs_event
->x
= bar
->start
;
9718 XSETINT (emacs_event
->x
, y
);
9720 XSETINT (emacs_event
->x
, y
);
9723 XSETINT (emacs_event
->y
, top_range
);
9727 /* Handle some mouse motion while someone is dragging the scroll bar.
9729 This may be called from a signal handler, so we have to ignore GC
9733 x_scroll_bar_note_movement (bar
, event
)
9734 struct scroll_bar
*bar
;
9737 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
9739 last_mouse_movement_time
= event
->xmotion
.time
;
9742 XSETVECTOR (last_mouse_scroll_bar
, bar
);
9744 /* If we're dragging the bar, display it. */
9745 if (! GC_NILP (bar
->dragging
))
9747 /* Where should the handle be now? */
9748 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
9750 if (new_start
!= XINT (bar
->start
))
9752 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
9754 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
9759 #endif /* !USE_TOOLKIT_SCROLL_BARS */
9761 /* Return information to the user about the current position of the mouse
9762 on the scroll bar. */
9765 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
9767 Lisp_Object
*bar_window
;
9768 enum scroll_bar_part
*part
;
9770 unsigned long *time
;
9772 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
9773 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9774 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9776 Window dummy_window
;
9778 unsigned int dummy_mask
;
9782 /* Get the mouse's position relative to the scroll bar window, and
9784 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
9786 /* Root, child, root x and root y. */
9787 &dummy_window
, &dummy_window
,
9788 &dummy_coord
, &dummy_coord
,
9790 /* Position relative to scroll bar. */
9793 /* Mouse buttons and modifier keys. */
9800 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9803 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9805 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
9807 if (! NILP (bar
->dragging
))
9808 win_y
-= XINT (bar
->dragging
);
9812 if (win_y
> top_range
)
9816 *bar_window
= bar
->window
;
9818 if (! NILP (bar
->dragging
))
9819 *part
= scroll_bar_handle
;
9820 else if (win_y
< XINT (bar
->start
))
9821 *part
= scroll_bar_above_handle
;
9822 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
9823 *part
= scroll_bar_handle
;
9825 *part
= scroll_bar_below_handle
;
9827 XSETINT (*x
, win_y
);
9828 XSETINT (*y
, top_range
);
9831 last_mouse_scroll_bar
= Qnil
;
9834 *time
= last_mouse_movement_time
;
9840 /* The screen has been cleared so we may have changed foreground or
9841 background colors, and the scroll bars may need to be redrawn.
9842 Clear out the scroll bars, and ask for expose events, so we can
9846 x_scroll_bar_clear (f
)
9849 #ifndef USE_TOOLKIT_SCROLL_BARS
9852 /* We can have scroll bars even if this is 0,
9853 if we just turned off scroll bar mode.
9854 But in that case we should not clear them. */
9855 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
9856 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
9857 bar
= XSCROLL_BAR (bar
)->next
)
9858 XClearArea (FRAME_X_DISPLAY (f
),
9859 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
9861 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9864 /* This processes Expose events from the menu-bar specific X event
9865 loop in xmenu.c. This allows to redisplay the frame if necessary
9866 when handling menu-bar or pop-up items. */
9869 process_expose_from_menu (event
)
9873 struct x_display_info
*dpyinfo
;
9874 int frame_exposed_p
= 0;
9878 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
9879 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
9882 if (f
->async_visible
== 0)
9884 f
->async_visible
= 1;
9885 f
->async_iconified
= 0;
9886 f
->output_data
.x
->has_been_visible
= 1;
9887 SET_FRAME_GARBAGED (f
);
9891 expose_frame (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
9892 event
.xexpose
.x
, event
.xexpose
.y
,
9893 event
.xexpose
.width
, event
.xexpose
.height
);
9894 frame_exposed_p
= 1;
9899 struct scroll_bar
*bar
9900 = x_window_to_scroll_bar (event
.xexpose
.window
);
9903 x_scroll_bar_expose (bar
, &event
);
9907 return frame_exposed_p
;
9910 /* Define a queue to save up SelectionRequest events for later handling. */
9912 struct selection_event_queue
9915 struct selection_event_queue
*next
;
9918 static struct selection_event_queue
*queue
;
9920 /* Nonzero means queue up certain events--don't process them yet. */
9922 static int x_queue_selection_requests
;
9924 /* Queue up an X event *EVENT, to be processed later. */
9927 x_queue_event (f
, event
)
9931 struct selection_event_queue
*queue_tmp
9932 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
9934 if (queue_tmp
!= NULL
)
9936 queue_tmp
->event
= *event
;
9937 queue_tmp
->next
= queue
;
9942 /* Take all the queued events and put them back
9943 so that they get processed afresh. */
9946 x_unqueue_events (display
)
9949 while (queue
!= NULL
)
9951 struct selection_event_queue
*queue_tmp
= queue
;
9952 XPutBackEvent (display
, &queue_tmp
->event
);
9953 queue
= queue_tmp
->next
;
9954 xfree ((char *)queue_tmp
);
9958 /* Start queuing SelectionRequest events. */
9961 x_start_queuing_selection_requests (display
)
9964 x_queue_selection_requests
++;
9967 /* Stop queuing SelectionRequest events. */
9970 x_stop_queuing_selection_requests (display
)
9973 x_queue_selection_requests
--;
9974 x_unqueue_events (display
);
9977 /* The main X event-reading loop - XTread_socket. */
9980 /* Time stamp of enter window event. This is only used by XTread_socket,
9981 but we have to put it out here, since static variables within functions
9982 sometimes don't work. */
9984 static Time enter_timestamp
;
9987 /* This holds the state XLookupString needs to implement dead keys
9988 and other tricks known as "compose processing". _X Window System_
9989 says that a portable program can't use this, but Stephen Gildea assures
9990 me that letting the compiler initialize it to zeros will work okay.
9992 This must be defined outside of XTread_socket, for the same reasons
9993 given for enter_timestamp, above. */
9995 static XComposeStatus compose_status
;
9997 /* Record the last 100 characters stored
9998 to help debug the loss-of-chars-during-GC problem. */
10000 static int temp_index
;
10001 static short temp_buffer
[100];
10003 /* Set this to nonzero to fake an "X I/O error"
10004 on a particular display. */
10006 struct x_display_info
*XTread_socket_fake_io_error
;
10008 /* When we find no input here, we occasionally do a no-op command
10009 to verify that the X server is still running and we can still talk with it.
10010 We try all the open displays, one by one.
10011 This variable is used for cycling thru the displays. */
10013 static struct x_display_info
*next_noop_dpyinfo
;
10015 #define SET_SAVED_MENU_EVENT(size) \
10018 if (f->output_data.x->saved_menu_event == 0) \
10019 f->output_data.x->saved_menu_event \
10020 = (XEvent *) xmalloc (sizeof (XEvent)); \
10021 bcopy (&event, f->output_data.x->saved_menu_event, size); \
10022 if (numchars >= 1) \
10024 bufp->kind = MENU_BAR_ACTIVATE_EVENT; \
10025 XSETFRAME (bufp->frame_or_window, f); \
10026 bufp->arg = Qnil; \
10034 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
10035 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
10037 /* Read events coming from the X server.
10038 This routine is called by the SIGIO handler.
10039 We return as soon as there are no more events to be read.
10041 Events representing keys are stored in buffer BUFP,
10042 which can hold up to NUMCHARS characters.
10043 We return the number of characters stored into the buffer,
10044 thus pretending to be `read'.
10046 EXPECTED is nonzero if the caller knows input is available. */
10049 XTread_socket (sd
, bufp
, numchars
, expected
)
10051 /* register */ struct input_event
*bufp
;
10052 /* register */ int numchars
;
10059 int event_found
= 0;
10060 struct x_display_info
*dpyinfo
;
10061 struct coding_system coding
;
10063 if (interrupt_input_blocked
)
10065 interrupt_input_pending
= 1;
10069 interrupt_input_pending
= 0;
10072 /* So people can tell when we have read the available input. */
10073 input_signal_count
++;
10076 abort (); /* Don't think this happens. */
10080 /* Find the display we are supposed to read input for.
10081 It's the one communicating on descriptor SD. */
10082 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
10084 #if 0 /* This ought to be unnecessary; let's verify it. */
10086 /* If available, Xlib uses FIOSNBIO to make the socket
10087 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
10088 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
10089 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
10090 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
10091 #endif /* ! defined (FIOSNBIO) */
10094 #if 0 /* This code can't be made to work, with multiple displays,
10095 and appears not to be used on any system any more.
10096 Also keyboard.c doesn't turn O_NDELAY on and off
10097 for X connections. */
10099 #ifndef HAVE_SELECT
10100 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
10102 extern int read_alarm_should_throw
;
10103 read_alarm_should_throw
= 1;
10104 XPeekEvent (dpyinfo
->display
, &event
);
10105 read_alarm_should_throw
= 0;
10107 #endif /* HAVE_SELECT */
10111 /* For debugging, this gives a way to fake an I/O error. */
10112 if (dpyinfo
== XTread_socket_fake_io_error
)
10114 XTread_socket_fake_io_error
= 0;
10115 x_io_error_quitter (dpyinfo
->display
);
10120 count
+= x_session_check_input (bufp
, &numchars
);
10124 while (XPending (dpyinfo
->display
))
10126 XNextEvent (dpyinfo
->display
, &event
);
10130 /* Filter events for the current X input method.
10131 XFilterEvent returns non-zero if the input method has
10132 consumed the event. We pass the frame's X window to
10133 XFilterEvent because that's the one for which the IC
10135 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
10136 event
.xclient
.window
);
10137 if (XFilterEvent (&event
, f1
? FRAME_X_WINDOW (f1
) : None
))
10143 switch (event
.type
)
10145 case ClientMessage
:
10147 if (event
.xclient
.message_type
10148 == dpyinfo
->Xatom_wm_protocols
10149 && event
.xclient
.format
== 32)
10151 if (event
.xclient
.data
.l
[0]
10152 == dpyinfo
->Xatom_wm_take_focus
)
10154 /* Use x_any_window_to_frame because this
10155 could be the shell widget window
10156 if the frame has no title bar. */
10157 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
10159 /* Not quite sure this is needed -pd */
10160 if (f
&& FRAME_XIC (f
))
10161 XSetICFocus (FRAME_XIC (f
));
10163 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
10164 instructs the WM to set the input focus automatically for
10165 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
10166 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
10167 it has set the focus. So, XSetInputFocus below is not
10170 The call to XSetInputFocus below has also caused trouble. In
10171 cases where the XSetInputFocus done by the WM and the one
10172 below are temporally close (on a fast machine), the call
10173 below can generate additional FocusIn events which confuse
10176 /* Since we set WM_TAKE_FOCUS, we must call
10177 XSetInputFocus explicitly. But not if f is null,
10178 since that might be an event for a deleted frame. */
10181 Display
*d
= event
.xclient
.display
;
10182 /* Catch and ignore errors, in case window has been
10183 iconified by a window manager such as GWM. */
10184 int count
= x_catch_errors (d
);
10185 XSetInputFocus (d
, event
.xclient
.window
,
10186 /* The ICCCM says this is
10187 the only valid choice. */
10189 event
.xclient
.data
.l
[1]);
10190 /* This is needed to detect the error
10191 if there is an error. */
10193 x_uncatch_errors (d
, count
);
10195 /* Not certain about handling scroll bars here */
10198 else if (event
.xclient
.data
.l
[0]
10199 == dpyinfo
->Xatom_wm_save_yourself
)
10201 /* Save state modify the WM_COMMAND property to
10202 something which can reinstate us. This notifies
10203 the session manager, who's looking for such a
10204 PropertyNotify. Can restart processing when
10205 a keyboard or mouse event arrives. */
10206 /* If we have a session manager, don't set this.
10207 KDE will then start two Emacsen, one for the
10208 session manager and one for this. */
10211 && ! x_session_have_connection ()
10215 f
= x_top_window_to_frame (dpyinfo
,
10216 event
.xclient
.window
);
10217 /* This is just so we only give real data once
10218 for a single Emacs process. */
10219 if (f
== SELECTED_FRAME ())
10220 XSetCommand (FRAME_X_DISPLAY (f
),
10221 event
.xclient
.window
,
10222 initial_argv
, initial_argc
);
10224 XSetCommand (FRAME_X_DISPLAY (f
),
10225 event
.xclient
.window
,
10229 else if (event
.xclient
.data
.l
[0]
10230 == dpyinfo
->Xatom_wm_delete_window
)
10233 = x_any_window_to_frame (dpyinfo
,
10234 event
.xclient
.window
);
10241 bufp
->kind
= DELETE_WINDOW_EVENT
;
10242 XSETFRAME (bufp
->frame_or_window
, f
);
10251 else if (event
.xclient
.message_type
10252 == dpyinfo
->Xatom_wm_configure_denied
)
10255 else if (event
.xclient
.message_type
10256 == dpyinfo
->Xatom_wm_window_moved
)
10260 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
10262 new_x
= event
.xclient
.data
.s
[0];
10263 new_y
= event
.xclient
.data
.s
[1];
10267 f
->output_data
.x
->left_pos
= new_x
;
10268 f
->output_data
.x
->top_pos
= new_y
;
10271 #ifdef HACK_EDITRES
10272 else if (event
.xclient
.message_type
10273 == dpyinfo
->Xatom_editres
)
10276 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
10277 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
10280 #endif /* HACK_EDITRES */
10281 else if ((event
.xclient
.message_type
10282 == dpyinfo
->Xatom_DONE
)
10283 || (event
.xclient
.message_type
10284 == dpyinfo
->Xatom_PAGE
))
10286 /* Ghostview job completed. Kill it. We could
10287 reply with "Next" if we received "Page", but we
10288 currently never do because we are interested in
10289 images, only, which should have 1 page. */
10290 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
10292 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
10293 x_kill_gs_process (pixmap
, f
);
10294 expose_frame (f
, 0, 0, 0, 0);
10296 #ifdef USE_TOOLKIT_SCROLL_BARS
10297 /* Scroll bar callbacks send a ClientMessage from which
10298 we construct an input_event. */
10299 else if (event
.xclient
.message_type
10300 == dpyinfo
->Xatom_Scrollbar
)
10302 x_scroll_bar_to_input_event (&event
, bufp
);
10303 ++bufp
, ++count
, --numchars
;
10306 #endif /* USE_TOOLKIT_SCROLL_BARS */
10312 case SelectionNotify
:
10313 #ifdef USE_X_TOOLKIT
10314 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
10316 #endif /* not USE_X_TOOLKIT */
10317 x_handle_selection_notify (&event
.xselection
);
10320 case SelectionClear
: /* Someone has grabbed ownership. */
10321 #ifdef USE_X_TOOLKIT
10322 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
10324 #endif /* USE_X_TOOLKIT */
10326 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
10331 bufp
->kind
= SELECTION_CLEAR_EVENT
;
10332 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
10333 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
10334 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
10335 bufp
->frame_or_window
= Qnil
;
10344 case SelectionRequest
: /* Someone wants our selection. */
10345 #ifdef USE_X_TOOLKIT
10346 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
10348 #endif /* USE_X_TOOLKIT */
10349 if (x_queue_selection_requests
)
10350 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
10354 XSelectionRequestEvent
*eventp
10355 = (XSelectionRequestEvent
*) &event
;
10360 bufp
->kind
= SELECTION_REQUEST_EVENT
;
10361 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
10362 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
10363 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
10364 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
10365 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
10366 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
10367 bufp
->frame_or_window
= Qnil
;
10376 case PropertyNotify
:
10377 #if 0 /* This is plain wrong. In the case that we are waiting for a
10378 PropertyNotify used as an ACK in incremental selection
10379 transfer, the property will be on the receiver's window. */
10380 #if defined USE_X_TOOLKIT
10381 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
10385 x_handle_property_notify (&event
.xproperty
);
10388 case ReparentNotify
:
10389 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
10393 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
10394 x_real_positions (f
, &x
, &y
);
10395 f
->output_data
.x
->left_pos
= x
;
10396 f
->output_data
.x
->top_pos
= y
;
10401 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
10404 x_check_fullscreen (f
);
10406 if (f
->async_visible
== 0)
10408 f
->async_visible
= 1;
10409 f
->async_iconified
= 0;
10410 f
->output_data
.x
->has_been_visible
= 1;
10411 SET_FRAME_GARBAGED (f
);
10414 expose_frame (x_window_to_frame (dpyinfo
,
10415 event
.xexpose
.window
),
10416 event
.xexpose
.x
, event
.xexpose
.y
,
10417 event
.xexpose
.width
, event
.xexpose
.height
);
10421 #ifndef USE_TOOLKIT_SCROLL_BARS
10422 struct scroll_bar
*bar
;
10424 #if defined USE_LUCID
10425 /* Submenus of the Lucid menu bar aren't widgets
10426 themselves, so there's no way to dispatch events
10427 to them. Recognize this case separately. */
10430 = x_window_to_menu_bar (event
.xexpose
.window
);
10432 xlwmenu_redisplay (widget
);
10434 #endif /* USE_LUCID */
10436 #ifdef USE_TOOLKIT_SCROLL_BARS
10437 /* Dispatch event to the widget. */
10439 #else /* not USE_TOOLKIT_SCROLL_BARS */
10440 bar
= x_window_to_scroll_bar (event
.xexpose
.window
);
10443 x_scroll_bar_expose (bar
, &event
);
10444 #ifdef USE_X_TOOLKIT
10447 #endif /* USE_X_TOOLKIT */
10448 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10452 case GraphicsExpose
: /* This occurs when an XCopyArea's
10453 source area was obscured or not
10455 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
10459 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
10460 event
.xgraphicsexpose
.width
,
10461 event
.xgraphicsexpose
.height
);
10463 #ifdef USE_X_TOOLKIT
10466 #endif /* USE_X_TOOLKIT */
10469 case NoExpose
: /* This occurs when an XCopyArea's
10470 source area was completely
10475 /* Redo the mouse-highlight after the tooltip has gone. */
10476 if (event
.xmap
.window
== tip_window
)
10479 redo_mouse_highlight ();
10482 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
10483 if (f
) /* F may no longer exist if
10484 the frame was deleted. */
10486 /* While a frame is unmapped, display generation is
10487 disabled; you don't want to spend time updating a
10488 display that won't ever be seen. */
10489 f
->async_visible
= 0;
10490 /* We can't distinguish, from the event, whether the window
10491 has become iconified or invisible. So assume, if it
10492 was previously visible, than now it is iconified.
10493 But x_make_frame_invisible clears both
10494 the visible flag and the iconified flag;
10495 and that way, we know the window is not iconified now. */
10496 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
10498 f
->async_iconified
= 1;
10500 bufp
->kind
= ICONIFY_EVENT
;
10501 XSETFRAME (bufp
->frame_or_window
, f
);
10511 if (event
.xmap
.window
== tip_window
)
10512 /* The tooltip has been drawn already. Avoid
10513 the SET_FRAME_GARBAGED below. */
10516 /* We use x_top_window_to_frame because map events can
10517 come for sub-windows and they don't mean that the
10518 frame is visible. */
10519 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
10522 f
->async_visible
= 1;
10523 f
->async_iconified
= 0;
10524 f
->output_data
.x
->has_been_visible
= 1;
10526 /* wait_reading_process_input will notice this and update
10527 the frame's display structures. */
10528 SET_FRAME_GARBAGED (f
);
10532 bufp
->kind
= DEICONIFY_EVENT
;
10533 XSETFRAME (bufp
->frame_or_window
, f
);
10539 else if (! NILP (Vframe_list
)
10540 && ! NILP (XCDR (Vframe_list
)))
10541 /* Force a redisplay sooner or later
10542 to update the frame titles
10543 in case this is the second frame. */
10544 record_asynch_buffer_change ();
10550 /* Dispatch KeyPress events when in menu. */
10551 if (popup_activated_flag
)
10554 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
10556 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
10558 dpyinfo
->mouse_face_hidden
= 1;
10559 clear_mouse_face (dpyinfo
);
10562 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
10565 /* Scroll bars consume key events, but we want
10566 the keys to go to the scroll bar's frame. */
10567 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
10568 event
.xkey
.window
);
10569 if (widget
&& XmIsScrollBar (widget
))
10571 widget
= XtParent (widget
);
10572 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
10575 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
10579 KeySym keysym
, orig_keysym
;
10580 /* al%imercury@uunet.uu.net says that making this 81
10581 instead of 80 fixed a bug whereby meta chars made
10584 It seems that some version of XmbLookupString has
10585 a bug of not returning XBufferOverflow in
10586 status_return even if the input is too long to
10587 fit in 81 bytes. So, we must prepare sufficient
10588 bytes for copy_buffer. 513 bytes (256 chars for
10589 two-byte character set) seems to be a fairly good
10590 approximation. -- 2000.8.10 handa@etl.go.jp */
10591 unsigned char copy_buffer
[513];
10592 unsigned char *copy_bufptr
= copy_buffer
;
10593 int copy_bufsiz
= sizeof (copy_buffer
);
10595 Lisp_Object coding_system
= Qlatin_1
;
10598 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
10599 extra_keyboard_modifiers
);
10600 modifiers
= event
.xkey
.state
;
10602 /* This will have to go some day... */
10604 /* make_lispy_event turns chars into control chars.
10605 Don't do it here because XLookupString is too eager. */
10606 event
.xkey
.state
&= ~ControlMask
;
10607 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
10608 | dpyinfo
->super_mod_mask
10609 | dpyinfo
->hyper_mod_mask
10610 | dpyinfo
->alt_mod_mask
);
10612 /* In case Meta is ComposeCharacter,
10613 clear its status. According to Markus Ehrnsperger
10614 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
10615 this enables ComposeCharacter to work whether or
10616 not it is combined with Meta. */
10617 if (modifiers
& dpyinfo
->meta_mod_mask
)
10618 bzero (&compose_status
, sizeof (compose_status
));
10623 Status status_return
;
10625 coding_system
= Vlocale_coding_system
;
10626 nbytes
= XmbLookupString (FRAME_XIC (f
),
10627 &event
.xkey
, copy_bufptr
,
10628 copy_bufsiz
, &keysym
,
10630 if (status_return
== XBufferOverflow
)
10632 copy_bufsiz
= nbytes
+ 1;
10633 copy_bufptr
= (char *) alloca (copy_bufsiz
);
10634 nbytes
= XmbLookupString (FRAME_XIC (f
),
10635 &event
.xkey
, copy_bufptr
,
10636 copy_bufsiz
, &keysym
,
10639 /* Xutf8LookupString is a new but already deprecated interface. -stef */
10640 #if 0 && defined X_HAVE_UTF8_STRING
10641 else if (status_return
== XLookupKeySym
)
10642 { /* Try again but with utf-8. */
10643 coding_system
= Qutf_8
;
10644 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
10645 &event
.xkey
, copy_bufptr
,
10646 copy_bufsiz
, &keysym
,
10648 if (status_return
== XBufferOverflow
)
10650 copy_bufsiz
= nbytes
+ 1;
10651 copy_bufptr
= (char *) alloca (copy_bufsiz
);
10652 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
10655 copy_bufsiz
, &keysym
,
10661 if (status_return
== XLookupNone
)
10663 else if (status_return
== XLookupChars
)
10668 else if (status_return
!= XLookupKeySym
10669 && status_return
!= XLookupBoth
)
10673 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
10674 copy_bufsiz
, &keysym
,
10677 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
10678 copy_bufsiz
, &keysym
,
10682 orig_keysym
= keysym
;
10686 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
10687 || keysym
== XK_Delete
10688 #ifdef XK_ISO_Left_Tab
10689 || (keysym
>= XK_ISO_Left_Tab
&& keysym
<= XK_ISO_Enter
)
10691 || (keysym
>= XK_Kanji
&& keysym
<= XK_Eisu_toggle
)
10692 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
10693 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
10695 /* This recognizes the "extended function keys".
10696 It seems there's no cleaner way.
10697 Test IsModifierKey to avoid handling mode_switch
10699 || ((unsigned) (keysym
) >= XK_Select
10700 && (unsigned)(keysym
) < XK_KP_Space
)
10702 #ifdef XK_dead_circumflex
10703 || orig_keysym
== XK_dead_circumflex
10705 #ifdef XK_dead_grave
10706 || orig_keysym
== XK_dead_grave
10708 #ifdef XK_dead_tilde
10709 || orig_keysym
== XK_dead_tilde
10711 #ifdef XK_dead_diaeresis
10712 || orig_keysym
== XK_dead_diaeresis
10714 #ifdef XK_dead_macron
10715 || orig_keysym
== XK_dead_macron
10717 #ifdef XK_dead_degree
10718 || orig_keysym
== XK_dead_degree
10720 #ifdef XK_dead_acute
10721 || orig_keysym
== XK_dead_acute
10723 #ifdef XK_dead_cedilla
10724 || orig_keysym
== XK_dead_cedilla
10726 #ifdef XK_dead_breve
10727 || orig_keysym
== XK_dead_breve
10729 #ifdef XK_dead_ogonek
10730 || orig_keysym
== XK_dead_ogonek
10732 #ifdef XK_dead_caron
10733 || orig_keysym
== XK_dead_caron
10735 #ifdef XK_dead_doubleacute
10736 || orig_keysym
== XK_dead_doubleacute
10738 #ifdef XK_dead_abovedot
10739 || orig_keysym
== XK_dead_abovedot
10741 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
10742 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
10743 /* Any "vendor-specific" key is ok. */
10744 || (orig_keysym
& (1 << 28))
10745 || (keysym
!= NoSymbol
&& nbytes
== 0))
10746 && ! (IsModifierKey (orig_keysym
)
10748 #ifdef XK_Mode_switch
10749 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
10752 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
10754 #endif /* not HAVE_X11R5 */
10755 /* The symbols from XK_ISO_Lock to
10756 XK_ISO_Last_Group_Lock doesn't have real
10757 modifiers but should be treated similarly
10758 to Mode_switch by Emacs. */
10759 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
10760 || ((unsigned)(orig_keysym
) >= XK_ISO_Lock
10761 && (unsigned)(orig_keysym
) <= XK_ISO_Last_Group_Lock
)
10765 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
10767 temp_buffer
[temp_index
++] = keysym
;
10768 bufp
->kind
= NON_ASCII_KEYSTROKE_EVENT
;
10769 bufp
->code
= keysym
;
10770 XSETFRAME (bufp
->frame_or_window
, f
);
10773 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
10775 bufp
->timestamp
= event
.xkey
.time
;
10780 else if (numchars
> nbytes
)
10786 /* The input should be decoded with `coding_system'
10787 which depends on which X*LookupString function
10788 we used just above and the locale. */
10789 setup_coding_system (coding_system
, &coding
);
10790 coding
.src_multibyte
= 0;
10791 coding
.dst_multibyte
= 1;
10792 /* The input is converted to events, thus we can't
10793 handle composition. Anyway, there's no XIM that
10794 gives us composition information. */
10795 coding
.composing
= COMPOSITION_DISABLED
;
10797 for (i
= 0; i
< nbytes
; i
++)
10799 if (temp_index
== (sizeof temp_buffer
10802 temp_buffer
[temp_index
++] = copy_bufptr
[i
];
10806 /* Decode the input data. */
10810 require
= decoding_buffer_size (&coding
, nbytes
);
10811 p
= (unsigned char *) alloca (require
);
10812 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
10813 /* We explicitely disable composition
10814 handling because key data should
10815 not contain any composition
10817 coding
.composing
= COMPOSITION_DISABLED
;
10818 decode_coding (&coding
, copy_bufptr
, p
,
10820 nbytes
= coding
.produced
;
10821 nchars
= coding
.produced_char
;
10825 /* Convert the input data to a sequence of
10826 character events. */
10827 for (i
= 0; i
< nbytes
; i
+= len
)
10829 if (nchars
== nbytes
)
10830 c
= copy_bufptr
[i
], len
= 1;
10832 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
10835 bufp
->kind
= (SINGLE_BYTE_CHAR_P (c
)
10836 ? ASCII_KEYSTROKE_EVENT
10837 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
10839 XSETFRAME (bufp
->frame_or_window
, f
);
10842 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
10844 bufp
->timestamp
= event
.xkey
.time
;
10849 numchars
-= nchars
;
10851 if (keysym
== NoSymbol
)
10861 /* Don't dispatch this event since XtDispatchEvent calls
10862 XFilterEvent, and two calls in a row may freeze the
10871 /* Don't dispatch this event since XtDispatchEvent calls
10872 XFilterEvent, and two calls in a row may freeze the
10883 n
= x_detect_focus_change (dpyinfo
, &event
, bufp
, numchars
);
10886 bufp
+= n
, count
+= n
, numchars
-= n
;
10889 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10892 if (event
.xcrossing
.focus
)
10894 /* Avoid nasty pop/raise loops. */
10895 if (f
&& (!(f
->auto_raise
)
10896 || !(f
->auto_lower
)
10897 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
10899 x_new_focus_frame (dpyinfo
, f
);
10900 enter_timestamp
= event
.xcrossing
.time
;
10903 else if (f
== dpyinfo
->x_focus_frame
)
10904 x_new_focus_frame (dpyinfo
, 0);
10907 /* EnterNotify counts as mouse movement,
10908 so update things that depend on mouse position. */
10909 if (f
&& !f
->output_data
.x
->hourglass_p
)
10910 note_mouse_movement (f
, &event
.xmotion
);
10918 n
= x_detect_focus_change (dpyinfo
, &event
, bufp
, numchars
);
10921 bufp
+= n
, count
+= n
, numchars
-= n
;
10931 n
= x_detect_focus_change (dpyinfo
, &event
, bufp
, numchars
);
10934 bufp
+= n
, count
+= n
, numchars
-= n
;
10938 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10941 if (f
== dpyinfo
->mouse_face_mouse_frame
)
10943 /* If we move outside the frame, then we're
10944 certainly no longer on any text in the frame. */
10945 clear_mouse_face (dpyinfo
);
10946 dpyinfo
->mouse_face_mouse_frame
= 0;
10949 /* Generate a nil HELP_EVENT to cancel a help-echo.
10950 Do it only if there's something to cancel.
10951 Otherwise, the startup message is cleared when
10952 the mouse leaves the frame. */
10953 if (any_help_event_p
)
10958 XSETFRAME (frame
, f
);
10960 n
= gen_help_event (bufp
, numchars
,
10961 Qnil
, frame
, Qnil
, Qnil
, 0);
10962 bufp
+= n
, count
+= n
, numchars
-= n
;
10972 n
= x_detect_focus_change (dpyinfo
, &event
, bufp
, numchars
);
10975 bufp
+= n
, count
+= n
, numchars
-= n
;
10983 previous_help_echo
= help_echo
;
10984 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
10985 help_echo_pos
= -1;
10987 if (dpyinfo
->grabbed
&& last_mouse_frame
10988 && FRAME_LIVE_P (last_mouse_frame
))
10989 f
= last_mouse_frame
;
10991 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
10993 if (dpyinfo
->mouse_face_hidden
)
10995 dpyinfo
->mouse_face_hidden
= 0;
10996 clear_mouse_face (dpyinfo
);
11002 /* Generate SELECT_WINDOW_EVENTs when needed. */
11003 if (mouse_autoselect_window
)
11005 Lisp_Object window
;
11008 window
= window_from_coordinates (f
,
11009 event
.xmotion
.x
, event
.xmotion
.y
,
11012 /* Window will be selected only when it is not selected now and
11013 last mouse movement event was not in it. Minibuffer window
11014 will be selected iff it is active. */
11015 if (WINDOWP(window
)
11016 && !EQ (window
, last_window
)
11017 && !EQ (window
, selected_window
)
11020 bufp
->kind
= SELECT_WINDOW_EVENT
;
11021 bufp
->frame_or_window
= window
;
11023 ++bufp
, ++count
, --numchars
;
11026 last_window
=window
;
11028 note_mouse_movement (f
, &event
.xmotion
);
11032 #ifndef USE_TOOLKIT_SCROLL_BARS
11033 struct scroll_bar
*bar
11034 = x_window_to_scroll_bar (event
.xmotion
.window
);
11037 x_scroll_bar_note_movement (bar
, &event
);
11038 #endif /* USE_TOOLKIT_SCROLL_BARS */
11040 /* If we move outside the frame, then we're
11041 certainly no longer on any text in the frame. */
11042 clear_mouse_face (dpyinfo
);
11045 /* If the contents of the global variable help_echo
11046 has changed, generate a HELP_EVENT. */
11047 if (!NILP (help_echo
)
11048 || !NILP (previous_help_echo
))
11054 XSETFRAME (frame
, f
);
11058 any_help_event_p
= 1;
11059 n
= gen_help_event (bufp
, numchars
, help_echo
, frame
,
11060 help_echo_window
, help_echo_object
,
11062 bufp
+= n
, count
+= n
, numchars
-= n
;
11068 case ConfigureNotify
:
11069 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
11072 #ifndef USE_X_TOOLKIT
11073 /* If there is a pending resize for fullscreen, don't
11074 do this one, the right one will come later.
11075 The toolkit version doesn't seem to need this, but we
11076 need to reset it below. */
11078 ((f
->output_data
.x
->want_fullscreen
& FULLSCREEN_WAIT
)
11079 && FRAME_NEW_WIDTH (f
) != 0);
11080 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
11081 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
11085 /* In the toolkit version, change_frame_size
11086 is called by the code that handles resizing
11087 of the EmacsFrame widget. */
11089 /* Even if the number of character rows and columns has
11090 not changed, the font size may have changed, so we need
11091 to check the pixel dimensions as well. */
11092 if (columns
!= f
->width
11093 || rows
!= f
->height
11094 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
11095 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
11097 change_frame_size (f
, rows
, columns
, 0, 1, 0);
11098 SET_FRAME_GARBAGED (f
);
11099 cancel_mouse_face (f
);
11103 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
11104 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
11106 /* What we have now is the position of Emacs's own window.
11107 Convert that to the position of the window manager window. */
11108 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
11109 &f
->output_data
.x
->top_pos
);
11111 x_check_fullscreen_move(f
);
11112 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_WAIT
)
11113 f
->output_data
.x
->want_fullscreen
&=
11114 ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
11116 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
11117 xic_set_statusarea (f
);
11120 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
11122 /* Since the WM decorations come below top_pos now,
11123 we must put them below top_pos in the future. */
11124 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11125 x_wm_set_size_hint (f
, (long) 0, 0);
11128 /* Some window managers pass (0,0) as the location of
11129 the window, and the Motif event handler stores it
11130 in the emacs widget, which messes up Motif menus. */
11131 if (event
.xconfigure
.x
== 0 && event
.xconfigure
.y
== 0)
11133 event
.xconfigure
.x
= f
->output_data
.x
->widget
->core
.x
;
11134 event
.xconfigure
.y
= f
->output_data
.x
->widget
->core
.y
;
11136 #endif /* USE_MOTIF */
11141 case ButtonRelease
:
11143 /* If we decide we want to generate an event to be seen
11144 by the rest of Emacs, we put it here. */
11145 struct input_event emacs_event
;
11146 int tool_bar_p
= 0;
11148 emacs_event
.kind
= NO_EVENT
;
11149 bzero (&compose_status
, sizeof (compose_status
));
11151 if (dpyinfo
->grabbed
11152 && last_mouse_frame
11153 && FRAME_LIVE_P (last_mouse_frame
))
11154 f
= last_mouse_frame
;
11156 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
11160 /* Is this in the tool-bar? */
11161 if (WINDOWP (f
->tool_bar_window
)
11162 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
11164 Lisp_Object window
;
11167 x
= event
.xbutton
.x
;
11168 y
= event
.xbutton
.y
;
11171 window
= window_from_coordinates (f
, x
, y
, &p
, 1);
11172 if (EQ (window
, f
->tool_bar_window
))
11174 x_handle_tool_bar_click (f
, &event
.xbutton
);
11180 if (!dpyinfo
->x_focus_frame
11181 || f
== dpyinfo
->x_focus_frame
)
11182 construct_mouse_click (&emacs_event
, &event
, f
);
11186 #ifndef USE_TOOLKIT_SCROLL_BARS
11187 struct scroll_bar
*bar
11188 = x_window_to_scroll_bar (event
.xbutton
.window
);
11191 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
11192 #endif /* not USE_TOOLKIT_SCROLL_BARS */
11195 if (event
.type
== ButtonPress
)
11197 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
11198 last_mouse_frame
= f
;
11199 /* Ignore any mouse motion that happened
11200 before this event; any subsequent mouse-movement
11201 Emacs events should reflect only motion after
11202 the ButtonPress. */
11204 f
->mouse_moved
= 0;
11207 last_tool_bar_item
= -1;
11211 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
11214 if (numchars
>= 1 && emacs_event
.kind
!= NO_EVENT
)
11216 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
11222 #ifdef USE_X_TOOLKIT
11223 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
11224 /* For a down-event in the menu bar,
11225 don't pass it to Xt right now.
11226 Instead, save it away
11227 and we will pass it to Xt from kbd_buffer_get_event.
11228 That way, we can run some Lisp code first. */
11229 if (f
&& event
.type
== ButtonPress
11230 /* Verify the event is really within the menu bar
11231 and not just sent to it due to grabbing. */
11232 && event
.xbutton
.x
>= 0
11233 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
11234 && event
.xbutton
.y
>= 0
11235 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
11236 && event
.xbutton
.same_screen
)
11238 SET_SAVED_BUTTON_EVENT
;
11239 XSETFRAME (last_mouse_press_frame
, f
);
11241 else if (event
.type
== ButtonPress
)
11243 last_mouse_press_frame
= Qnil
;
11247 #ifdef USE_MOTIF /* This should do not harm for Lucid,
11248 but I am trying to be cautious. */
11249 else if (event
.type
== ButtonRelease
)
11251 if (!NILP (last_mouse_press_frame
))
11253 f
= XFRAME (last_mouse_press_frame
);
11254 if (f
->output_data
.x
)
11255 SET_SAVED_BUTTON_EVENT
;
11260 #endif /* USE_MOTIF */
11263 #endif /* USE_X_TOOLKIT */
11267 case CirculateNotify
:
11270 case CirculateRequest
:
11273 case VisibilityNotify
:
11276 case MappingNotify
:
11277 /* Someone has changed the keyboard mapping - update the
11279 switch (event
.xmapping
.request
)
11281 case MappingModifier
:
11282 x_find_modifier_meanings (dpyinfo
);
11283 /* This is meant to fall through. */
11284 case MappingKeyboard
:
11285 XRefreshKeyboardMapping (&event
.xmapping
);
11291 #ifdef USE_X_TOOLKIT
11293 XtDispatchEvent (&event
);
11295 #endif /* USE_X_TOOLKIT */
11303 /* On some systems, an X bug causes Emacs to get no more events
11304 when the window is destroyed. Detect that. (1994.) */
11307 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
11308 One XNOOP in 100 loops will make Emacs terminate.
11309 B. Bretthauer, 1994 */
11311 if (x_noop_count
>= 100)
11315 if (next_noop_dpyinfo
== 0)
11316 next_noop_dpyinfo
= x_display_list
;
11318 XNoOp (next_noop_dpyinfo
->display
);
11320 /* Each time we get here, cycle through the displays now open. */
11321 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
11325 /* If the focus was just given to an auto-raising frame,
11327 /* ??? This ought to be able to handle more than one such frame. */
11328 if (pending_autoraise_frame
)
11330 x_raise_frame (pending_autoraise_frame
);
11331 pending_autoraise_frame
= 0;
11342 /***********************************************************************
11344 ***********************************************************************/
11346 /* Notice when the text cursor of window W has been completely
11347 overwritten by a drawing operation that outputs glyphs in AREA
11348 starting at X0 and ending at X1 in the line starting at Y0 and
11349 ending at Y1. X coordinates are area-relative. X1 < 0 means all
11350 the rest of the line after X0 has been written. Y coordinates
11351 are window-relative. */
11354 notice_overwritten_cursor (w
, area
, x0
, x1
, y0
, y1
)
11356 enum glyph_row_area area
;
11357 int x0
, y0
, x1
, y1
;
11359 if (area
== TEXT_AREA
&& w
->phys_cursor_on_p
)
11361 int cx0
= w
->phys_cursor
.x
;
11362 int cx1
= cx0
+ w
->phys_cursor_width
;
11363 int cy0
= w
->phys_cursor
.y
;
11364 int cy1
= cy0
+ w
->phys_cursor_height
;
11366 if (x0
<= cx0
&& (x1
< 0 || x1
>= cx1
))
11368 /* The cursor image will be completely removed from the
11369 screen if the output area intersects the cursor area in
11370 y-direction. When we draw in [y0 y1[, and some part of
11371 the cursor is at y < y0, that part must have been drawn
11372 before. When scrolling, the cursor is erased before
11373 actually scrolling, so we don't come here. When not
11374 scrolling, the rows above the old cursor row must have
11375 changed, and in this case these rows must have written
11376 over the cursor image.
11378 Likewise if part of the cursor is below y1, with the
11379 exception of the cursor being in the first blank row at
11380 the buffer and window end because update_text_area
11381 doesn't draw that row. (Except when it does, but
11382 that's handled in update_text_area.) */
11384 if (((y0
>= cy0
&& y0
< cy1
) || (y1
> cy0
&& y1
< cy1
))
11385 && w
->current_matrix
->rows
[w
->phys_cursor
.vpos
].displays_text_p
)
11386 w
->phys_cursor_on_p
= 0;
11392 /* Set clipping for output in glyph row ROW. W is the window in which
11393 we operate. GC is the graphics context to set clipping in.
11394 WHOLE_LINE_P non-zero means include the areas used for truncation
11395 mark display and alike in the clipping rectangle.
11397 ROW may be a text row or, e.g., a mode line. Text rows must be
11398 clipped to the interior of the window dedicated to text display,
11399 mode lines must be clipped to the whole window. */
11402 x_clip_to_row (w
, row
, gc
, whole_line_p
)
11404 struct glyph_row
*row
;
11408 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
11409 XRectangle clip_rect
;
11410 int window_x
, window_y
, window_width
, window_height
;
11412 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
11414 clip_rect
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
11415 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
11416 clip_rect
.y
= max (clip_rect
.y
, window_y
);
11417 clip_rect
.width
= window_width
;
11418 clip_rect
.height
= row
->visible_height
;
11420 /* If clipping to the whole line, including trunc marks, extend
11421 the rectangle to the left and increase its width. */
11424 clip_rect
.x
-= FRAME_X_LEFT_FRINGE_WIDTH (f
);
11425 clip_rect
.width
+= FRAME_X_FRINGE_WIDTH (f
);
11428 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
11432 /* Draw a hollow box cursor on window W in glyph row ROW. */
11435 x_draw_hollow_cursor (w
, row
)
11437 struct glyph_row
*row
;
11439 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
11440 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11441 Display
*dpy
= FRAME_X_DISPLAY (f
);
11444 struct glyph
*cursor_glyph
;
11447 /* Compute frame-relative coordinates from window-relative
11449 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
11450 y
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
11451 + row
->ascent
- w
->phys_cursor_ascent
);
11452 h
= row
->height
- 1;
11454 /* Get the glyph the cursor is on. If we can't tell because
11455 the current matrix is invalid or such, give up. */
11456 cursor_glyph
= get_phys_cursor_glyph (w
);
11457 if (cursor_glyph
== NULL
)
11460 /* Compute the width of the rectangle to draw. If on a stretch
11461 glyph, and `x-stretch-block-cursor' is nil, don't draw a
11462 rectangle as wide as the glyph, but use a canonical character
11464 wd
= cursor_glyph
->pixel_width
- 1;
11465 if (cursor_glyph
->type
== STRETCH_GLYPH
11466 && !x_stretch_cursor_p
)
11467 wd
= min (CANON_X_UNIT (f
), wd
);
11468 w
->phys_cursor_width
= wd
;
11470 /* The foreground of cursor_gc is typically the same as the normal
11471 background color, which can cause the cursor box to be invisible. */
11472 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
11473 if (dpyinfo
->scratch_cursor_gc
)
11474 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
11476 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
11477 GCForeground
, &xgcv
);
11478 gc
= dpyinfo
->scratch_cursor_gc
;
11480 /* Set clipping, draw the rectangle, and reset clipping again. */
11481 x_clip_to_row (w
, row
, gc
, 0);
11482 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
11483 XSetClipMask (dpy
, gc
, None
);
11487 /* Draw a bar cursor on window W in glyph row ROW.
11489 Implementation note: One would like to draw a bar cursor with an
11490 angle equal to the one given by the font property XA_ITALIC_ANGLE.
11491 Unfortunately, I didn't find a font yet that has this property set.
11495 x_draw_bar_cursor (w
, row
, width
, kind
)
11497 struct glyph_row
*row
;
11499 enum text_cursor_kinds kind
;
11501 struct frame
*f
= XFRAME (w
->frame
);
11502 struct glyph
*cursor_glyph
;
11504 /* If cursor is out of bounds, don't draw garbage. This can happen
11505 in mini-buffer windows when switching between echo area glyphs
11506 and mini-buffer. */
11507 cursor_glyph
= get_phys_cursor_glyph (w
);
11508 if (cursor_glyph
== NULL
)
11511 /* If on an image, draw like a normal cursor. That's usually better
11512 visible than drawing a bar, esp. if the image is large so that
11513 the bar might not be in the window. */
11514 if (cursor_glyph
->type
== IMAGE_GLYPH
)
11516 struct glyph_row
*row
;
11517 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
11518 x_draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
11522 Display
*dpy
= FRAME_X_DISPLAY (f
);
11523 Window window
= FRAME_X_WINDOW (f
);
11524 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
11525 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
11526 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
11529 /* If the glyph's background equals the color we normally draw
11530 the bar cursor in, the bar cursor in its normal color is
11531 invisible. Use the glyph's foreground color instead in this
11532 case, on the assumption that the glyph's colors are chosen so
11533 that the glyph is legible. */
11534 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
11535 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
11537 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
11538 xgcv
.graphics_exposures
= 0;
11541 XChangeGC (dpy
, gc
, mask
, &xgcv
);
11544 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
11545 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
11549 width
= f
->output_data
.x
->cursor_width
;
11550 width
= min (cursor_glyph
->pixel_width
, width
);
11552 w
->phys_cursor_width
= width
;
11553 x_clip_to_row (w
, row
, gc
, 0);
11555 if (kind
== BAR_CURSOR
)
11556 XFillRectangle (dpy
, window
, gc
,
11557 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
11558 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
11559 width
, row
->height
);
11561 XFillRectangle (dpy
, window
, gc
,
11562 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
11563 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
11564 row
->height
- width
),
11565 cursor_glyph
->pixel_width
,
11568 XSetClipMask (dpy
, gc
, None
);
11573 /* Clear the cursor of window W to background color, and mark the
11574 cursor as not shown. This is used when the text where the cursor
11575 is is about to be rewritten. */
11581 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
11582 x_update_window_cursor (w
, 0);
11586 /* Draw the cursor glyph of window W in glyph row ROW. See the
11587 comment of x_draw_glyphs for the meaning of HL. */
11590 x_draw_phys_cursor_glyph (w
, row
, hl
)
11592 struct glyph_row
*row
;
11593 enum draw_glyphs_face hl
;
11595 /* If cursor hpos is out of bounds, don't draw garbage. This can
11596 happen in mini-buffer windows when switching between echo area
11597 glyphs and mini-buffer. */
11598 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
11600 int on_p
= w
->phys_cursor_on_p
;
11603 x1
= x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
11604 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
11606 w
->phys_cursor_on_p
= on_p
;
11608 if (hl
== DRAW_CURSOR
)
11609 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
11611 /* When we erase the cursor, and ROW is overlapped by other
11612 rows, make sure that these overlapping parts of other rows
11614 else if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
11616 if (row
> w
->current_matrix
->rows
11617 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
11618 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
11620 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
11621 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
11622 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
11628 /* Erase the image of a cursor of window W from the screen. */
11631 x_erase_phys_cursor (w
)
11634 struct frame
*f
= XFRAME (w
->frame
);
11635 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11636 int hpos
= w
->phys_cursor
.hpos
;
11637 int vpos
= w
->phys_cursor
.vpos
;
11638 int mouse_face_here_p
= 0;
11639 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
11640 struct glyph_row
*cursor_row
;
11641 struct glyph
*cursor_glyph
;
11642 enum draw_glyphs_face hl
;
11644 /* No cursor displayed or row invalidated => nothing to do on the
11646 if (w
->phys_cursor_type
== NO_CURSOR
)
11647 goto mark_cursor_off
;
11649 /* VPOS >= active_glyphs->nrows means that window has been resized.
11650 Don't bother to erase the cursor. */
11651 if (vpos
>= active_glyphs
->nrows
)
11652 goto mark_cursor_off
;
11654 /* If row containing cursor is marked invalid, there is nothing we
11656 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
11657 if (!cursor_row
->enabled_p
)
11658 goto mark_cursor_off
;
11660 /* If row is completely invisible, don't attempt to delete a cursor which
11661 isn't there. This can happen if cursor is at top of a window, and
11662 we switch to a buffer with a header line in that window. */
11663 if (cursor_row
->visible_height
<= 0)
11664 goto mark_cursor_off
;
11666 /* This can happen when the new row is shorter than the old one.
11667 In this case, either x_draw_glyphs or clear_end_of_line
11668 should have cleared the cursor. Note that we wouldn't be
11669 able to erase the cursor in this case because we don't have a
11670 cursor glyph at hand. */
11671 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
11672 goto mark_cursor_off
;
11674 /* If the cursor is in the mouse face area, redisplay that when
11675 we clear the cursor. */
11676 if (! NILP (dpyinfo
->mouse_face_window
)
11677 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
11678 && (vpos
> dpyinfo
->mouse_face_beg_row
11679 || (vpos
== dpyinfo
->mouse_face_beg_row
11680 && hpos
>= dpyinfo
->mouse_face_beg_col
))
11681 && (vpos
< dpyinfo
->mouse_face_end_row
11682 || (vpos
== dpyinfo
->mouse_face_end_row
11683 && hpos
< dpyinfo
->mouse_face_end_col
))
11684 /* Don't redraw the cursor's spot in mouse face if it is at the
11685 end of a line (on a newline). The cursor appears there, but
11686 mouse highlighting does not. */
11687 && cursor_row
->used
[TEXT_AREA
] > hpos
)
11688 mouse_face_here_p
= 1;
11690 /* Maybe clear the display under the cursor. */
11691 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
11694 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
11696 cursor_glyph
= get_phys_cursor_glyph (w
);
11697 if (cursor_glyph
== NULL
)
11698 goto mark_cursor_off
;
11700 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
11702 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11704 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
11706 cursor_glyph
->pixel_width
,
11707 cursor_row
->visible_height
,
11711 /* Erase the cursor by redrawing the character underneath it. */
11712 if (mouse_face_here_p
)
11713 hl
= DRAW_MOUSE_FACE
;
11715 hl
= DRAW_NORMAL_TEXT
;
11716 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
11719 w
->phys_cursor_on_p
= 0;
11720 w
->phys_cursor_type
= NO_CURSOR
;
11724 /* Non-zero if physical cursor of window W is within mouse face. */
11727 cursor_in_mouse_face_p (w
)
11730 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
11731 int in_mouse_face
= 0;
11733 if (WINDOWP (dpyinfo
->mouse_face_window
)
11734 && XWINDOW (dpyinfo
->mouse_face_window
) == w
)
11736 int hpos
= w
->phys_cursor
.hpos
;
11737 int vpos
= w
->phys_cursor
.vpos
;
11739 if (vpos
>= dpyinfo
->mouse_face_beg_row
11740 && vpos
<= dpyinfo
->mouse_face_end_row
11741 && (vpos
> dpyinfo
->mouse_face_beg_row
11742 || hpos
>= dpyinfo
->mouse_face_beg_col
)
11743 && (vpos
< dpyinfo
->mouse_face_end_row
11744 || hpos
< dpyinfo
->mouse_face_end_col
11745 || dpyinfo
->mouse_face_past_end
))
11749 return in_mouse_face
;
11753 /* Display or clear cursor of window W. If ON is zero, clear the
11754 cursor. If it is non-zero, display the cursor. If ON is nonzero,
11755 where to put the cursor is specified by HPOS, VPOS, X and Y. */
11758 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
11760 int on
, hpos
, vpos
, x
, y
;
11762 struct frame
*f
= XFRAME (w
->frame
);
11763 int new_cursor_type
;
11764 int new_cursor_width
;
11765 int cursor_off_state
= 0;
11766 struct glyph_matrix
*current_glyphs
;
11767 struct glyph_row
*glyph_row
;
11768 struct glyph
*glyph
;
11770 /* This is pointless on invisible frames, and dangerous on garbaged
11771 windows and frames; in the latter case, the frame or window may
11772 be in the midst of changing its size, and x and y may be off the
11774 if (! FRAME_VISIBLE_P (f
)
11775 || FRAME_GARBAGED_P (f
)
11776 || vpos
>= w
->current_matrix
->nrows
11777 || hpos
>= w
->current_matrix
->matrix_w
)
11780 /* If cursor is off and we want it off, return quickly. */
11781 if (!on
&& !w
->phys_cursor_on_p
)
11784 current_glyphs
= w
->current_matrix
;
11785 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
11786 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
11788 /* If cursor row is not enabled, we don't really know where to
11789 display the cursor. */
11790 if (!glyph_row
->enabled_p
)
11792 w
->phys_cursor_on_p
= 0;
11796 xassert (interrupt_input_blocked
);
11798 /* Set new_cursor_type to the cursor we want to be displayed. In a
11799 mini-buffer window, we want the cursor only to appear if we are
11800 reading input from this window. For the selected window, we want
11801 the cursor type given by the frame parameter. If explicitly
11802 marked off, draw no cursor. In all other cases, we want a hollow
11804 new_cursor_width
= -1;
11805 new_cursor_type
= -2;
11808 if (cursor_in_echo_area
11809 && FRAME_HAS_MINIBUF_P (f
)
11810 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
11812 if (w
== XWINDOW (echo_area_window
))
11813 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
11814 else if (NILP (Fbuffer_local_value (Qcursor_in_non_selected_windows
,
11816 new_cursor_type
= NO_CURSOR
;
11818 cursor_off_state
= 1;
11821 /* Nonselected window or nonselected frame. */
11822 else if (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
11823 || w
!= XWINDOW (f
->selected_window
))
11825 if ((MINI_WINDOW_P (w
) && minibuf_level
== 0)
11826 || NILP (Fbuffer_local_value (Qcursor_in_non_selected_windows
,
11828 || NILP (XBUFFER (w
->buffer
)->cursor_type
))
11829 new_cursor_type
= NO_CURSOR
;
11831 cursor_off_state
= 1;
11834 /* If new_cursor_type isn't decided yet, decide it now. */
11835 if (new_cursor_type
== -2)
11837 struct buffer
*b
= XBUFFER (w
->buffer
);
11839 if (EQ (b
->cursor_type
, Qt
))
11840 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
11842 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
11843 &new_cursor_width
);
11846 /* Dim out or hollow out the cursor,
11847 if it has blinked off or for nonselected windows. */
11848 if (w
->cursor_off_p
|| cursor_off_state
)
11850 if (new_cursor_type
== FILLED_BOX_CURSOR
)
11851 new_cursor_type
= HOLLOW_BOX_CURSOR
;
11852 else if (new_cursor_type
== BAR_CURSOR
&& new_cursor_width
> 1)
11853 new_cursor_width
= 1;
11855 new_cursor_type
= NO_CURSOR
;
11858 /* Now new_cursor_type is correct. */
11860 /* If cursor is currently being shown and we don't want it to be or
11861 it is in the wrong place, or the cursor type is not what we want,
11863 if (w
->phys_cursor_on_p
11865 || w
->phys_cursor
.x
!= x
11866 || w
->phys_cursor
.y
!= y
11867 || new_cursor_type
!= w
->phys_cursor_type
11868 || (new_cursor_type
== BAR_CURSOR
11869 && new_cursor_width
!= w
->phys_cursor_width
)))
11870 x_erase_phys_cursor (w
);
11872 /* Don't check phys_cursor_on_p here because that flag is only set
11873 to zero in some cases where we know that the cursor has been
11874 completely erased, to avoid the extra work of erasing the cursor
11875 twice. In other words, phys_cursor_on_p can be 1 and the cursor
11876 still not be visible, or it has only been partly erased. */
11879 w
->phys_cursor_ascent
= glyph_row
->ascent
;
11880 w
->phys_cursor_height
= glyph_row
->height
;
11882 /* Set phys_cursor_.* before x_draw_.* is called because some
11883 of them may need the information. */
11884 w
->phys_cursor
.x
= x
;
11885 w
->phys_cursor
.y
= glyph_row
->y
;
11886 w
->phys_cursor
.hpos
= hpos
;
11887 w
->phys_cursor
.vpos
= vpos
;
11888 w
->phys_cursor_type
= new_cursor_type
;
11889 w
->phys_cursor_on_p
= 1;
11891 switch (new_cursor_type
)
11893 case HOLLOW_BOX_CURSOR
:
11894 x_draw_hollow_cursor (w
, glyph_row
);
11897 case FILLED_BOX_CURSOR
:
11898 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
11902 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
, BAR_CURSOR
);
11906 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
, HBAR_CURSOR
);
11910 w
->phys_cursor_width
= 0;
11918 if (w
== XWINDOW (f
->selected_window
))
11919 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
11920 xic_set_preeditarea (w
, x
, y
);
11925 if (updating_frame
!= f
)
11926 XFlush (FRAME_X_DISPLAY (f
));
11931 /* Display the cursor on window W, or clear it. X and Y are window
11932 relative pixel coordinates. HPOS and VPOS are glyph matrix
11933 positions. If W is not the selected window, display a hollow
11934 cursor. ON non-zero means display the cursor at X, Y which
11935 correspond to HPOS, VPOS, otherwise it is cleared. */
11938 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
11940 int on
, hpos
, vpos
, x
, y
;
11943 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
11948 /* Display the cursor on window W, or clear it, according to ON_P.
11949 Don't change the cursor's position. */
11952 x_update_cursor (f
, on_p
)
11955 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
11959 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
11960 in the window tree rooted at W. */
11963 x_update_cursor_in_window_tree (w
, on_p
)
11969 if (!NILP (w
->hchild
))
11970 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
11971 else if (!NILP (w
->vchild
))
11972 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
11974 x_update_window_cursor (w
, on_p
);
11976 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
11981 /* Switch the display of W's cursor on or off, according to the value
11985 x_update_window_cursor (w
, on
)
11989 /* Don't update cursor in windows whose frame is in the process
11990 of being deleted. */
11991 if (w
->current_matrix
)
11994 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
11995 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
12005 /* Make the x-window of frame F use the gnu icon bitmap. */
12008 x_bitmap_icon (f
, file
)
12014 if (FRAME_X_WINDOW (f
) == 0)
12017 /* Free up our existing icon bitmap if any. */
12018 if (f
->output_data
.x
->icon_bitmap
> 0)
12019 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
12020 f
->output_data
.x
->icon_bitmap
= 0;
12022 if (STRINGP (file
))
12023 bitmap_id
= x_create_bitmap_from_file (f
, file
);
12026 /* Create the GNU bitmap if necessary. */
12027 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
12028 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
12029 = x_create_bitmap_from_data (f
, gnu_bits
,
12030 gnu_width
, gnu_height
);
12032 /* The first time we create the GNU bitmap,
12033 this increments the ref-count one extra time.
12034 As a result, the GNU bitmap is never freed.
12035 That way, we don't have to worry about allocating it again. */
12036 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
12038 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
12041 x_wm_set_icon_pixmap (f
, bitmap_id
);
12042 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
12048 /* Make the x-window of frame F use a rectangle with text.
12049 Use ICON_NAME as the text. */
12052 x_text_icon (f
, icon_name
)
12056 if (FRAME_X_WINDOW (f
) == 0)
12061 XTextProperty text
;
12062 text
.value
= (unsigned char *) icon_name
;
12063 text
.encoding
= XA_STRING
;
12065 text
.nitems
= strlen (icon_name
);
12066 #ifdef USE_X_TOOLKIT
12067 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
12069 #else /* not USE_X_TOOLKIT */
12070 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
12071 #endif /* not USE_X_TOOLKIT */
12073 #else /* not HAVE_X11R4 */
12074 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
12075 #endif /* not HAVE_X11R4 */
12077 if (f
->output_data
.x
->icon_bitmap
> 0)
12078 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
12079 f
->output_data
.x
->icon_bitmap
= 0;
12080 x_wm_set_icon_pixmap (f
, 0);
12085 #define X_ERROR_MESSAGE_SIZE 200
12087 /* If non-nil, this should be a string.
12088 It means catch X errors and store the error message in this string. */
12090 static Lisp_Object x_error_message_string
;
12092 /* An X error handler which stores the error message in
12093 x_error_message_string. This is called from x_error_handler if
12094 x_catch_errors is in effect. */
12097 x_error_catcher (display
, error
)
12099 XErrorEvent
*error
;
12101 XGetErrorText (display
, error
->error_code
,
12102 SDATA (x_error_message_string
),
12103 X_ERROR_MESSAGE_SIZE
);
12106 /* Begin trapping X errors for display DPY. Actually we trap X errors
12107 for all displays, but DPY should be the display you are actually
12110 After calling this function, X protocol errors no longer cause
12111 Emacs to exit; instead, they are recorded in the string
12112 stored in x_error_message_string.
12114 Calling x_check_errors signals an Emacs error if an X error has
12115 occurred since the last call to x_catch_errors or x_check_errors.
12117 Calling x_uncatch_errors resumes the normal error handling. */
12119 void x_check_errors ();
12120 static Lisp_Object
x_catch_errors_unwind ();
12123 x_catch_errors (dpy
)
12126 int count
= SPECPDL_INDEX ();
12128 /* Make sure any errors from previous requests have been dealt with. */
12129 XSync (dpy
, False
);
12131 record_unwind_protect (x_catch_errors_unwind
, x_error_message_string
);
12133 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
12134 SSET (x_error_message_string
, 0, 0);
12139 /* Unbind the binding that we made to check for X errors. */
12142 x_catch_errors_unwind (old_val
)
12143 Lisp_Object old_val
;
12145 x_error_message_string
= old_val
;
12149 /* If any X protocol errors have arrived since the last call to
12150 x_catch_errors or x_check_errors, signal an Emacs error using
12151 sprintf (a buffer, FORMAT, the x error message text) as the text. */
12154 x_check_errors (dpy
, format
)
12158 /* Make sure to catch any errors incurred so far. */
12159 XSync (dpy
, False
);
12161 if (SREF (x_error_message_string
, 0))
12162 error (format
, SDATA (x_error_message_string
));
12165 /* Nonzero if we had any X protocol errors
12166 since we did x_catch_errors on DPY. */
12169 x_had_errors_p (dpy
)
12172 /* Make sure to catch any errors incurred so far. */
12173 XSync (dpy
, False
);
12175 return SREF (x_error_message_string
, 0) != 0;
12178 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
12181 x_clear_errors (dpy
)
12184 SSET (x_error_message_string
, 0, 0);
12187 /* Stop catching X protocol errors and let them make Emacs die.
12188 DPY should be the display that was passed to x_catch_errors.
12189 COUNT should be the value that was returned by
12190 the corresponding call to x_catch_errors. */
12193 x_uncatch_errors (dpy
, count
)
12197 unbind_to (count
, Qnil
);
12201 static unsigned int x_wire_count
;
12204 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
12209 /* Handle SIGPIPE, which can happen when the connection to a server
12210 simply goes away. SIGPIPE is handled by x_connection_signal.
12211 Don't need to do anything, because the write which caused the
12212 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
12213 which will do the appropriate cleanup for us. */
12216 x_connection_signal (signalnum
) /* If we don't have an argument, */
12217 int signalnum
; /* some compilers complain in signal calls. */
12220 /* USG systems forget handlers when they are used;
12221 must reestablish each time */
12222 signal (signalnum
, x_connection_signal
);
12227 /************************************************************************
12229 ************************************************************************/
12231 /* Error message passed to x_connection_closed. */
12233 static char *error_msg
;
12235 /* Function installed as fatal_error_signal_hook in
12236 x_connection_closed. Print the X error message, and exit normally,
12237 instead of dumping core when XtCloseDisplay fails. */
12240 x_fatal_error_signal ()
12242 fprintf (stderr
, "%s\n", error_msg
);
12246 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
12247 the text of an error message that lead to the connection loss. */
12250 x_connection_closed (dpy
, error_message
)
12252 char *error_message
;
12254 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
12255 Lisp_Object frame
, tail
;
12258 error_msg
= (char *) alloca (strlen (error_message
) + 1);
12259 strcpy (error_msg
, error_message
);
12260 handling_signal
= 0;
12262 /* Prevent being called recursively because of an error condition
12263 below. Otherwise, we might end up with printing ``can't find per
12264 display information'' in the recursive call instead of printing
12265 the original message here. */
12266 count
= x_catch_errors (dpy
);
12268 /* We have to close the display to inform Xt that it doesn't
12269 exist anymore. If we don't, Xt will continue to wait for
12270 events from the display. As a consequence, a sequence of
12272 M-x make-frame-on-display RET :1 RET
12273 ...kill the new frame, so that we get an IO error...
12274 M-x make-frame-on-display RET :1 RET
12276 will indefinitely wait in Xt for events for display `:1', opened
12277 in the first class to make-frame-on-display.
12279 Closing the display is reported to lead to a bus error on
12280 OpenWindows in certain situations. I suspect that is a bug
12281 in OpenWindows. I don't know how to cicumvent it here. */
12283 #ifdef USE_X_TOOLKIT
12284 /* If DPYINFO is null, this means we didn't open the display
12285 in the first place, so don't try to close it. */
12288 extern void (*fatal_error_signal_hook
) P_ ((void));
12289 fatal_error_signal_hook
= x_fatal_error_signal
;
12290 XtCloseDisplay (dpy
);
12291 fatal_error_signal_hook
= NULL
;
12295 /* Indicate that this display is dead. */
12297 dpyinfo
->display
= 0;
12299 /* First delete frames whose mini-buffers are on frames
12300 that are on the dead display. */
12301 FOR_EACH_FRAME (tail
, frame
)
12303 Lisp_Object minibuf_frame
;
12305 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
12306 if (FRAME_X_P (XFRAME (frame
))
12307 && FRAME_X_P (XFRAME (minibuf_frame
))
12308 && ! EQ (frame
, minibuf_frame
)
12309 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
12310 Fdelete_frame (frame
, Qt
);
12313 /* Now delete all remaining frames on the dead display.
12314 We are now sure none of these is used as the mini-buffer
12315 for another frame that we need to delete. */
12316 FOR_EACH_FRAME (tail
, frame
)
12317 if (FRAME_X_P (XFRAME (frame
))
12318 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
12320 /* Set this to t so that Fdelete_frame won't get confused
12321 trying to find a replacement. */
12322 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
12323 Fdelete_frame (frame
, Qt
);
12327 x_delete_display (dpyinfo
);
12329 x_uncatch_errors (dpy
, count
);
12331 if (x_display_list
== 0)
12333 fprintf (stderr
, "%s\n", error_msg
);
12334 shut_down_emacs (0, 0, Qnil
);
12338 /* Ordinary stack unwind doesn't deal with these. */
12340 sigunblock (sigmask (SIGIO
));
12342 sigunblock (sigmask (SIGALRM
));
12343 TOTALLY_UNBLOCK_INPUT
;
12345 clear_waiting_for_input ();
12346 error ("%s", error_msg
);
12350 /* This is the usual handler for X protocol errors.
12351 It kills all frames on the display that we got the error for.
12352 If that was the only one, it prints an error message and kills Emacs. */
12355 x_error_quitter (display
, error
)
12357 XErrorEvent
*error
;
12359 char buf
[256], buf1
[356];
12361 /* Note that there is no real way portable across R3/R4 to get the
12362 original error handler. */
12364 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
12365 sprintf (buf1
, "X protocol error: %s on protocol request %d",
12366 buf
, error
->request_code
);
12367 x_connection_closed (display
, buf1
);
12371 /* This is the first-level handler for X protocol errors.
12372 It calls x_error_quitter or x_error_catcher. */
12375 x_error_handler (display
, error
)
12377 XErrorEvent
*error
;
12379 if (! NILP (x_error_message_string
))
12380 x_error_catcher (display
, error
);
12382 x_error_quitter (display
, error
);
12386 /* This is the handler for X IO errors, always.
12387 It kills all frames on the display that we lost touch with.
12388 If that was the only one, it prints an error message and kills Emacs. */
12391 x_io_error_quitter (display
)
12396 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
12397 x_connection_closed (display
, buf
);
12401 /* Changing the font of the frame. */
12403 /* Give frame F the font named FONTNAME as its default font, and
12404 return the full name of that font. FONTNAME may be a wildcard
12405 pattern; in that case, we choose some font that fits the pattern.
12406 The return value shows which font we chose. */
12409 x_new_font (f
, fontname
)
12411 register char *fontname
;
12413 struct font_info
*fontp
12414 = FS_LOAD_FONT (f
, 0, fontname
, -1);
12419 f
->output_data
.x
->font
= (XFontStruct
*) (fontp
->font
);
12420 f
->output_data
.x
->baseline_offset
= fontp
->baseline_offset
;
12421 f
->output_data
.x
->fontset
= -1;
12423 x_compute_fringe_widths (f
, 1);
12425 /* Compute the scroll bar width in character columns. */
12426 if (f
->scroll_bar_pixel_width
> 0)
12428 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
12429 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
12433 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
12434 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
12437 /* Now make the frame display the given font. */
12438 if (FRAME_X_WINDOW (f
) != 0)
12440 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
12441 f
->output_data
.x
->font
->fid
);
12442 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
12443 f
->output_data
.x
->font
->fid
);
12444 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
12445 f
->output_data
.x
->font
->fid
);
12447 frame_update_line_height (f
);
12449 /* Don't change the size of a tip frame; there's no point in
12450 doing it because it's done in Fx_show_tip, and it leads to
12451 problems because the tip frame has no widget. */
12452 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
12453 x_set_window_size (f
, 0, f
->width
, f
->height
);
12456 /* If we are setting a new frame's font for the first time,
12457 there are no faces yet, so this font's height is the line height. */
12458 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
12460 return build_string (fontp
->full_name
);
12463 /* Give frame F the fontset named FONTSETNAME as its default font, and
12464 return the full name of that fontset. FONTSETNAME may be a wildcard
12465 pattern; in that case, we choose some fontset that fits the pattern.
12466 The return value shows which fontset we chose. */
12469 x_new_fontset (f
, fontsetname
)
12473 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
12474 Lisp_Object result
;
12479 if (f
->output_data
.x
->fontset
== fontset
)
12480 /* This fontset is already set in frame F. There's nothing more
12482 return fontset_name (fontset
);
12484 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
12486 if (!STRINGP (result
))
12487 /* Can't load ASCII font. */
12490 /* Since x_new_font doesn't update any fontset information, do it now. */
12491 f
->output_data
.x
->fontset
= fontset
;
12495 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
12496 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
12499 return build_string (fontsetname
);
12502 /* Compute actual fringe widths */
12505 x_compute_fringe_widths (f
, redraw
)
12509 int o_left
= f
->output_data
.x
->left_fringe_width
;
12510 int o_right
= f
->output_data
.x
->right_fringe_width
;
12511 int o_cols
= f
->output_data
.x
->fringe_cols
;
12513 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
12514 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
12515 int left_fringe_width
, right_fringe_width
;
12517 if (!NILP (left_fringe
))
12518 left_fringe
= Fcdr (left_fringe
);
12519 if (!NILP (right_fringe
))
12520 right_fringe
= Fcdr (right_fringe
);
12522 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
12523 XINT (left_fringe
));
12524 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
12525 XINT (right_fringe
));
12527 if (left_fringe_width
|| right_fringe_width
)
12529 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
12530 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
12531 int conf_wid
= left_wid
+ right_wid
;
12532 int font_wid
= FONT_WIDTH (f
->output_data
.x
->font
);
12533 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
12534 int real_wid
= cols
* font_wid
;
12535 if (left_wid
&& right_wid
)
12537 if (left_fringe_width
< 0)
12539 /* Left fringe width is fixed, adjust right fringe if necessary */
12540 f
->output_data
.x
->left_fringe_width
= left_wid
;
12541 f
->output_data
.x
->right_fringe_width
= real_wid
- left_wid
;
12543 else if (right_fringe_width
< 0)
12545 /* Right fringe width is fixed, adjust left fringe if necessary */
12546 f
->output_data
.x
->left_fringe_width
= real_wid
- right_wid
;
12547 f
->output_data
.x
->right_fringe_width
= right_wid
;
12551 /* Adjust both fringes with an equal amount.
12552 Note that we are doing integer arithmetic here, so don't
12553 lose a pixel if the total width is an odd number. */
12554 int fill
= real_wid
- conf_wid
;
12555 f
->output_data
.x
->left_fringe_width
= left_wid
+ fill
/2;
12556 f
->output_data
.x
->right_fringe_width
= right_wid
+ fill
- fill
/2;
12559 else if (left_fringe_width
)
12561 f
->output_data
.x
->left_fringe_width
= real_wid
;
12562 f
->output_data
.x
->right_fringe_width
= 0;
12566 f
->output_data
.x
->left_fringe_width
= 0;
12567 f
->output_data
.x
->right_fringe_width
= real_wid
;
12569 f
->output_data
.x
->fringe_cols
= cols
;
12570 f
->output_data
.x
->fringes_extra
= real_wid
;
12574 f
->output_data
.x
->left_fringe_width
= 0;
12575 f
->output_data
.x
->right_fringe_width
= 0;
12576 f
->output_data
.x
->fringe_cols
= 0;
12577 f
->output_data
.x
->fringes_extra
= 0;
12580 if (redraw
&& FRAME_VISIBLE_P (f
))
12581 if (o_left
!= f
->output_data
.x
->left_fringe_width
||
12582 o_right
!= f
->output_data
.x
->right_fringe_width
||
12583 o_cols
!= f
->output_data
.x
->fringe_cols
)
12587 /***********************************************************************
12589 ***********************************************************************/
12595 /* XIM destroy callback function, which is called whenever the
12596 connection to input method XIM dies. CLIENT_DATA contains a
12597 pointer to the x_display_info structure corresponding to XIM. */
12600 xim_destroy_callback (xim
, client_data
, call_data
)
12602 XPointer client_data
;
12603 XPointer call_data
;
12605 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
12606 Lisp_Object frame
, tail
;
12610 /* No need to call XDestroyIC.. */
12611 FOR_EACH_FRAME (tail
, frame
)
12613 struct frame
*f
= XFRAME (frame
);
12614 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
12616 FRAME_XIC (f
) = NULL
;
12617 if (FRAME_XIC_FONTSET (f
))
12619 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
12620 FRAME_XIC_FONTSET (f
) = NULL
;
12625 /* No need to call XCloseIM. */
12626 dpyinfo
->xim
= NULL
;
12627 XFree (dpyinfo
->xim_styles
);
12631 #endif /* HAVE_X11R6 */
12633 /* Open the connection to the XIM server on display DPYINFO.
12634 RESOURCE_NAME is the resource name Emacs uses. */
12637 xim_open_dpy (dpyinfo
, resource_name
)
12638 struct x_display_info
*dpyinfo
;
12639 char *resource_name
;
12644 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
, EMACS_CLASS
);
12645 dpyinfo
->xim
= xim
;
12650 XIMCallback destroy
;
12653 /* Get supported styles and XIM values. */
12654 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
12657 destroy
.callback
= xim_destroy_callback
;
12658 destroy
.client_data
= (XPointer
)dpyinfo
;
12659 /* This isn't prototyped in OSF 5.0. */
12660 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
12664 #else /* not USE_XIM */
12665 dpyinfo
->xim
= NULL
;
12666 #endif /* not USE_XIM */
12670 #ifdef HAVE_X11R6_XIM
12674 struct x_display_info
*dpyinfo
;
12675 char *resource_name
;
12678 /* XIM instantiate callback function, which is called whenever an XIM
12679 server is available. DISPLAY is teh display of the XIM.
12680 CLIENT_DATA contains a pointer to an xim_inst_t structure created
12681 when the callback was registered. */
12684 xim_instantiate_callback (display
, client_data
, call_data
)
12686 XPointer client_data
;
12687 XPointer call_data
;
12689 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
12690 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
12692 /* We don't support multiple XIM connections. */
12696 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
12698 /* Create XIC for the existing frames on the same display, as long
12699 as they have no XIC. */
12700 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
12702 Lisp_Object tail
, frame
;
12705 FOR_EACH_FRAME (tail
, frame
)
12707 struct frame
*f
= XFRAME (frame
);
12709 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
12710 if (FRAME_XIC (f
) == NULL
)
12712 create_frame_xic (f
);
12713 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
12714 xic_set_statusarea (f
);
12715 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
12717 struct window
*w
= XWINDOW (f
->selected_window
);
12718 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
12727 #endif /* HAVE_X11R6_XIM */
12730 /* Open a connection to the XIM server on display DPYINFO.
12731 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
12732 connection only at the first time. On X11R6, open the connection
12733 in the XIM instantiate callback function. */
12736 xim_initialize (dpyinfo
, resource_name
)
12737 struct x_display_info
*dpyinfo
;
12738 char *resource_name
;
12741 #ifdef HAVE_X11R6_XIM
12742 struct xim_inst_t
*xim_inst
;
12745 dpyinfo
->xim
= NULL
;
12746 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
12747 xim_inst
->dpyinfo
= dpyinfo
;
12748 len
= strlen (resource_name
);
12749 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
12750 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
12751 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
12752 resource_name
, EMACS_CLASS
,
12753 xim_instantiate_callback
,
12754 /* Fixme: This is XPointer in
12755 XFree86 but (XPointer *) on
12756 Tru64, at least. */
12757 (XPointer
) xim_inst
);
12758 #else /* not HAVE_X11R6_XIM */
12759 dpyinfo
->xim
= NULL
;
12760 xim_open_dpy (dpyinfo
, resource_name
);
12761 #endif /* not HAVE_X11R6_XIM */
12763 #else /* not USE_XIM */
12764 dpyinfo
->xim
= NULL
;
12765 #endif /* not USE_XIM */
12769 /* Close the connection to the XIM server on display DPYINFO. */
12772 xim_close_dpy (dpyinfo
)
12773 struct x_display_info
*dpyinfo
;
12776 #ifdef HAVE_X11R6_XIM
12777 if (dpyinfo
->display
)
12778 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
12780 xim_instantiate_callback
, NULL
);
12781 #endif /* not HAVE_X11R6_XIM */
12782 if (dpyinfo
->display
)
12783 XCloseIM (dpyinfo
->xim
);
12784 dpyinfo
->xim
= NULL
;
12785 XFree (dpyinfo
->xim_styles
);
12786 #endif /* USE_XIM */
12789 #endif /* not HAVE_X11R6_XIM */
12793 /* Calculate the absolute position in frame F
12794 from its current recorded position values and gravity. */
12797 x_calc_absolute_position (f
)
12801 int win_x
= 0, win_y
= 0;
12802 int flags
= f
->output_data
.x
->size_hint_flags
;
12805 /* We have nothing to do if the current position
12806 is already for the top-left corner. */
12807 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
12810 #ifdef USE_X_TOOLKIT
12811 this_window
= XtWindow (f
->output_data
.x
->widget
);
12813 this_window
= FRAME_X_WINDOW (f
);
12816 /* Find the position of the outside upper-left corner of
12817 the inner window, with respect to the outer window.
12818 But do this only if we will need the results. */
12819 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
12824 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
12827 x_clear_errors (FRAME_X_DISPLAY (f
));
12828 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
12830 /* From-window, to-window. */
12832 f
->output_data
.x
->parent_desc
,
12834 /* From-position, to-position. */
12835 0, 0, &win_x
, &win_y
,
12837 /* Child of win. */
12839 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
12841 Window newroot
, newparent
= 0xdeadbeef;
12842 Window
*newchildren
;
12843 unsigned int nchildren
;
12845 if (! XQueryTree (FRAME_X_DISPLAY (f
), this_window
, &newroot
,
12846 &newparent
, &newchildren
, &nchildren
))
12849 XFree ((char *) newchildren
);
12851 f
->output_data
.x
->parent_desc
= newparent
;
12857 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
12861 /* Treat negative positions as relative to the leftmost bottommost
12862 position that fits on the screen. */
12863 if (flags
& XNegative
)
12864 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
12865 - 2 * f
->output_data
.x
->border_width
- win_x
12867 + f
->output_data
.x
->left_pos
);
12870 int height
= PIXEL_HEIGHT (f
);
12872 #if defined USE_X_TOOLKIT && defined USE_MOTIF
12873 /* Something is fishy here. When using Motif, starting Emacs with
12874 `-g -0-0', the frame appears too low by a few pixels.
12876 This seems to be so because initially, while Emacs is starting,
12877 the column widget's height and the frame's pixel height are
12878 different. The column widget's height is the right one. In
12879 later invocations, when Emacs is up, the frame's pixel height
12882 It's not obvious where the initial small difference comes from.
12883 2000-12-01, gerd. */
12885 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
12888 if (flags
& YNegative
)
12889 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
12890 - 2 * f
->output_data
.x
->border_width
12893 + f
->output_data
.x
->top_pos
);
12896 /* The left_pos and top_pos
12897 are now relative to the top and left screen edges,
12898 so the flags should correspond. */
12899 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
12902 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
12903 to really change the position, and 0 when calling from
12904 x_make_frame_visible (in that case, XOFF and YOFF are the current
12905 position values). It is -1 when calling from x_set_frame_parameters,
12906 which means, do adjust for borders but don't change the gravity. */
12909 x_set_offset (f
, xoff
, yoff
, change_gravity
)
12911 register int xoff
, yoff
;
12912 int change_gravity
;
12914 int modified_top
, modified_left
;
12916 if (change_gravity
> 0)
12918 f
->output_data
.x
->top_pos
= yoff
;
12919 f
->output_data
.x
->left_pos
= xoff
;
12920 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
12922 f
->output_data
.x
->size_hint_flags
|= XNegative
;
12924 f
->output_data
.x
->size_hint_flags
|= YNegative
;
12925 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
12927 x_calc_absolute_position (f
);
12930 x_wm_set_size_hint (f
, (long) 0, 0);
12932 modified_left
= f
->output_data
.x
->left_pos
;
12933 modified_top
= f
->output_data
.x
->top_pos
;
12934 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
12935 this seems to be unnecessary and incorrect. rms, 4/17/97. */
12936 /* It is a mystery why we need to add the border_width here
12937 when the frame is already visible, but experiment says we do. */
12938 if (change_gravity
!= 0)
12940 modified_left
+= f
->output_data
.x
->border_width
;
12941 modified_top
+= f
->output_data
.x
->border_width
;
12945 #ifdef USE_X_TOOLKIT
12946 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
12947 modified_left
, modified_top
);
12948 #else /* not USE_X_TOOLKIT */
12949 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
12950 modified_left
, modified_top
);
12951 #endif /* not USE_X_TOOLKIT */
12955 /* Check if we need to resize the frame due to a fullscreen request.
12956 If so needed, resize the frame. */
12958 x_check_fullscreen (f
)
12961 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_BOTH
)
12963 int width
, height
, ign
;
12965 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
12966 &f
->output_data
.x
->top_pos
);
12968 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
12970 /* We do not need to move the window, it shall be taken care of
12971 when setting WM manager hints.
12972 If the frame is visible already, the position is checked by
12973 x_check_fullscreen_move. */
12974 if (f
->width
!= width
|| f
->height
!= height
)
12976 change_frame_size (f
, height
, width
, 0, 1, 0);
12977 SET_FRAME_GARBAGED (f
);
12978 cancel_mouse_face (f
);
12980 /* Wait for the change of frame size to occur */
12981 f
->output_data
.x
->want_fullscreen
|= FULLSCREEN_WAIT
;
12987 /* If frame parameters are set after the frame is mapped, we need to move
12988 the window. This is done in xfns.c.
12989 Some window managers moves the window to the right position, some
12990 moves the outer window manager window to the specified position.
12991 Here we check that we are in the right spot. If not, make a second
12992 move, assuming we are dealing with the second kind of window manager. */
12994 x_check_fullscreen_move (f
)
12997 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_MOVE_WAIT
)
12999 int expect_top
= f
->output_data
.x
->top_pos
;
13000 int expect_left
= f
->output_data
.x
->left_pos
;
13002 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_HEIGHT
)
13004 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_WIDTH
)
13007 if (expect_top
!= f
->output_data
.x
->top_pos
13008 || expect_left
!= f
->output_data
.x
->left_pos
)
13009 x_set_offset (f
, expect_left
, expect_top
, 1);
13011 /* Just do this once */
13012 f
->output_data
.x
->want_fullscreen
&= ~FULLSCREEN_MOVE_WAIT
;
13017 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
13018 wanted positions of the WM window (not emacs window).
13019 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
13020 window (FRAME_X_WINDOW).
13023 x_fullscreen_adjust (f
, width
, height
, top_pos
, left_pos
)
13030 int newwidth
= f
->width
, newheight
= f
->height
;
13032 *top_pos
= f
->output_data
.x
->top_pos
;
13033 *left_pos
= f
->output_data
.x
->left_pos
;
13035 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_HEIGHT
)
13039 ph
= FRAME_X_DISPLAY_INFO (f
)->height
;
13040 newheight
= PIXEL_TO_CHAR_HEIGHT (f
, ph
);
13041 ph
= CHAR_TO_PIXEL_HEIGHT (f
, newheight
)
13042 - f
->output_data
.x
->y_pixels_diff
;
13043 newheight
= PIXEL_TO_CHAR_HEIGHT (f
, ph
);
13047 if (f
->output_data
.x
->want_fullscreen
& FULLSCREEN_WIDTH
)
13051 pw
= FRAME_X_DISPLAY_INFO (f
)->width
;
13052 newwidth
= PIXEL_TO_CHAR_WIDTH (f
, pw
);
13053 pw
= CHAR_TO_PIXEL_WIDTH (f
, newwidth
)
13054 - f
->output_data
.x
->x_pixels_diff
;
13055 newwidth
= PIXEL_TO_CHAR_WIDTH (f
, pw
);
13060 *height
= newheight
;
13064 /* Change the size of frame F's X window to COLS/ROWS in the case F
13065 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
13066 top-left-corner window gravity for this size change and subsequent
13067 size changes. Otherwise we leave the window gravity unchanged. */
13070 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
13072 int change_gravity
;
13075 int pixelwidth
, pixelheight
;
13077 check_frame_size (f
, &rows
, &cols
);
13078 f
->output_data
.x
->vertical_scroll_bar_extra
13079 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
13081 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
13082 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
13083 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
13085 x_compute_fringe_widths (f
, 0);
13087 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
13088 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
13090 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
13091 x_wm_set_size_hint (f
, (long) 0, 0);
13093 XSync (FRAME_X_DISPLAY (f
), False
);
13094 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
13095 pixelwidth
, pixelheight
);
13097 /* Now, strictly speaking, we can't be sure that this is accurate,
13098 but the window manager will get around to dealing with the size
13099 change request eventually, and we'll hear how it went when the
13100 ConfigureNotify event gets here.
13102 We could just not bother storing any of this information here,
13103 and let the ConfigureNotify event set everything up, but that
13104 might be kind of confusing to the Lisp code, since size changes
13105 wouldn't be reported in the frame parameters until some random
13106 point in the future when the ConfigureNotify event arrives.
13108 We pass 1 for DELAY since we can't run Lisp code inside of
13110 change_frame_size (f
, rows
, cols
, 0, 1, 0);
13111 PIXEL_WIDTH (f
) = pixelwidth
;
13112 PIXEL_HEIGHT (f
) = pixelheight
;
13114 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
13115 receive in the ConfigureNotify event; if we get what we asked
13116 for, then the event won't cause the screen to become garbaged, so
13117 we have to make sure to do it here. */
13118 SET_FRAME_GARBAGED (f
);
13120 XFlush (FRAME_X_DISPLAY (f
));
13124 /* Call this to change the size of frame F's x-window.
13125 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
13126 for this size change and subsequent size changes.
13127 Otherwise we leave the window gravity unchanged. */
13130 x_set_window_size (f
, change_gravity
, cols
, rows
)
13132 int change_gravity
;
13137 #ifdef USE_X_TOOLKIT
13139 if (f
->output_data
.x
->widget
!= NULL
)
13141 /* The x and y position of the widget is clobbered by the
13142 call to XtSetValues within EmacsFrameSetCharSize.
13143 This is a real kludge, but I don't understand Xt so I can't
13144 figure out a correct fix. Can anyone else tell me? -- rms. */
13145 int xpos
= f
->output_data
.x
->widget
->core
.x
;
13146 int ypos
= f
->output_data
.x
->widget
->core
.y
;
13147 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
13148 f
->output_data
.x
->widget
->core
.x
= xpos
;
13149 f
->output_data
.x
->widget
->core
.y
= ypos
;
13152 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
13154 #else /* not USE_X_TOOLKIT */
13156 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
13158 #endif /* not USE_X_TOOLKIT */
13160 /* If cursor was outside the new size, mark it as off. */
13161 mark_window_cursors_off (XWINDOW (f
->root_window
));
13163 /* Clear out any recollection of where the mouse highlighting was,
13164 since it might be in a place that's outside the new frame size.
13165 Actually checking whether it is outside is a pain in the neck,
13166 so don't try--just let the highlighting be done afresh with new size. */
13167 cancel_mouse_face (f
);
13172 /* Mouse warping. */
13175 x_set_mouse_position (f
, x
, y
)
13181 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
13182 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
13184 if (pix_x
< 0) pix_x
= 0;
13185 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
13187 if (pix_y
< 0) pix_y
= 0;
13188 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
13192 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
13193 0, 0, 0, 0, pix_x
, pix_y
);
13197 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
13200 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
13206 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
13207 0, 0, 0, 0, pix_x
, pix_y
);
13211 /* focus shifting, raising and lowering. */
13214 x_focus_on_frame (f
)
13217 #if 0 /* This proves to be unpleasant. */
13221 /* I don't think that the ICCCM allows programs to do things like this
13222 without the interaction of the window manager. Whatever you end up
13223 doing with this code, do it to x_unfocus_frame too. */
13224 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
13225 RevertToPointerRoot
, CurrentTime
);
13230 x_unfocus_frame (f
)
13234 /* Look at the remarks in x_focus_on_frame. */
13235 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
13236 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
13237 RevertToPointerRoot
, CurrentTime
);
13241 /* Raise frame F. */
13247 if (f
->async_visible
)
13250 #ifdef USE_X_TOOLKIT
13251 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
13252 #else /* not USE_X_TOOLKIT */
13253 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13254 #endif /* not USE_X_TOOLKIT */
13255 XFlush (FRAME_X_DISPLAY (f
));
13260 /* Lower frame F. */
13266 if (f
->async_visible
)
13269 #ifdef USE_X_TOOLKIT
13270 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
13271 #else /* not USE_X_TOOLKIT */
13272 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13273 #endif /* not USE_X_TOOLKIT */
13274 XFlush (FRAME_X_DISPLAY (f
));
13280 XTframe_raise_lower (f
, raise_flag
)
13290 /* Change of visibility. */
13292 /* This tries to wait until the frame is really visible.
13293 However, if the window manager asks the user where to position
13294 the frame, this will return before the user finishes doing that.
13295 The frame will not actually be visible at that time,
13296 but it will become visible later when the window manager
13297 finishes with it. */
13300 x_make_frame_visible (f
)
13304 int original_top
, original_left
;
13305 int retry_count
= 2;
13311 type
= x_icon_type (f
);
13313 x_bitmap_icon (f
, type
);
13315 if (! FRAME_VISIBLE_P (f
))
13317 /* We test FRAME_GARBAGED_P here to make sure we don't
13318 call x_set_offset a second time
13319 if we get to x_make_frame_visible a second time
13320 before the window gets really visible. */
13321 if (! FRAME_ICONIFIED_P (f
)
13322 && ! f
->output_data
.x
->asked_for_visible
)
13323 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
13325 f
->output_data
.x
->asked_for_visible
= 1;
13327 if (! EQ (Vx_no_window_manager
, Qt
))
13328 x_wm_set_window_state (f
, NormalState
);
13329 #ifdef USE_X_TOOLKIT
13330 /* This was XtPopup, but that did nothing for an iconified frame. */
13331 XtMapWidget (f
->output_data
.x
->widget
);
13332 #else /* not USE_X_TOOLKIT */
13333 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13334 #endif /* not USE_X_TOOLKIT */
13335 #if 0 /* This seems to bring back scroll bars in the wrong places
13336 if the window configuration has changed. They seem
13337 to come back ok without this. */
13338 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
13339 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13343 XFlush (FRAME_X_DISPLAY (f
));
13345 /* Synchronize to ensure Emacs knows the frame is visible
13346 before we do anything else. We do this loop with input not blocked
13347 so that incoming events are handled. */
13351 /* This must be before UNBLOCK_INPUT
13352 since events that arrive in response to the actions above
13353 will set it when they are handled. */
13354 int previously_visible
= f
->output_data
.x
->has_been_visible
;
13356 original_left
= f
->output_data
.x
->left_pos
;
13357 original_top
= f
->output_data
.x
->top_pos
;
13359 /* This must come after we set COUNT. */
13362 /* We unblock here so that arriving X events are processed. */
13364 /* Now move the window back to where it was "supposed to be".
13365 But don't do it if the gravity is negative.
13366 When the gravity is negative, this uses a position
13367 that is 3 pixels too low. Perhaps that's really the border width.
13369 Don't do this if the window has never been visible before,
13370 because the window manager may choose the position
13371 and we don't want to override it. */
13373 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
13374 && f
->output_data
.x
->win_gravity
== NorthWestGravity
13375 && previously_visible
)
13379 unsigned int width
, height
, border
, depth
;
13383 /* On some window managers (such as FVWM) moving an existing
13384 window, even to the same place, causes the window manager
13385 to introduce an offset. This can cause the window to move
13386 to an unexpected location. Check the geometry (a little
13387 slow here) and then verify that the window is in the right
13388 place. If the window is not in the right place, move it
13389 there, and take the potential window manager hit. */
13390 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
13391 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
13393 if (original_left
!= x
|| original_top
!= y
)
13394 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
13395 original_left
, original_top
);
13400 XSETFRAME (frame
, f
);
13402 /* Wait until the frame is visible. Process X events until a
13403 MapNotify event has been seen, or until we think we won't get a
13404 MapNotify at all.. */
13405 for (count
= input_signal_count
+ 10;
13406 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
13408 /* Force processing of queued events. */
13411 /* Machines that do polling rather than SIGIO have been
13412 observed to go into a busy-wait here. So we'll fake an
13413 alarm signal to let the handler know that there's something
13414 to be read. We used to raise a real alarm, but it seems
13415 that the handler isn't always enabled here. This is
13417 if (input_polling_used ())
13419 /* It could be confusing if a real alarm arrives while
13420 processing the fake one. Turn it off and let the
13421 handler reset it. */
13422 extern void poll_for_input_1
P_ ((void));
13423 int old_poll_suppress_count
= poll_suppress_count
;
13424 poll_suppress_count
= 1;
13425 poll_for_input_1 ();
13426 poll_suppress_count
= old_poll_suppress_count
;
13429 /* See if a MapNotify event has been processed. */
13430 FRAME_SAMPLE_VISIBILITY (f
);
13435 (let ((f (selected-frame)))
13439 the frame is not raised with various window managers on
13440 FreeBSD, Linux and Solaris. It turns out that, for some
13441 unknown reason, the call to XtMapWidget is completely ignored.
13442 Mapping the widget a second time works. */
13444 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
13449 /* Change from mapped state to withdrawn state. */
13451 /* Make the frame visible (mapped and not iconified). */
13454 x_make_frame_invisible (f
)
13459 #ifdef USE_X_TOOLKIT
13460 /* Use the frame's outermost window, not the one we normally draw on. */
13461 window
= XtWindow (f
->output_data
.x
->widget
);
13462 #else /* not USE_X_TOOLKIT */
13463 window
= FRAME_X_WINDOW (f
);
13464 #endif /* not USE_X_TOOLKIT */
13466 /* Don't keep the highlight on an invisible frame. */
13467 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
13468 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
13470 #if 0/* This might add unreliability; I don't trust it -- rms. */
13471 if (! f
->async_visible
&& ! f
->async_iconified
)
13477 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
13478 that the current position of the window is user-specified, rather than
13479 program-specified, so that when the window is mapped again, it will be
13480 placed at the same location, without forcing the user to position it
13481 by hand again (they have already done that once for this window.) */
13482 x_wm_set_size_hint (f
, (long) 0, 1);
13486 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
13487 DefaultScreen (FRAME_X_DISPLAY (f
))))
13489 UNBLOCK_INPUT_RESIGNAL
;
13490 error ("Can't notify window manager of window withdrawal");
13492 #else /* ! defined (HAVE_X11R4) */
13494 /* Tell the window manager what we're going to do. */
13495 if (! EQ (Vx_no_window_manager
, Qt
))
13499 unmap
.xunmap
.type
= UnmapNotify
;
13500 unmap
.xunmap
.window
= window
;
13501 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
13502 unmap
.xunmap
.from_configure
= False
;
13503 if (! XSendEvent (FRAME_X_DISPLAY (f
),
13504 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
13506 SubstructureRedirectMaskSubstructureNotifyMask
,
13509 UNBLOCK_INPUT_RESIGNAL
;
13510 error ("Can't notify window manager of withdrawal");
13514 /* Unmap the window ourselves. Cheeky! */
13515 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
13516 #endif /* ! defined (HAVE_X11R4) */
13518 /* We can't distinguish this from iconification
13519 just by the event that we get from the server.
13520 So we can't win using the usual strategy of letting
13521 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
13522 and synchronize with the server to make sure we agree. */
13524 FRAME_ICONIFIED_P (f
) = 0;
13525 f
->async_visible
= 0;
13526 f
->async_iconified
= 0;
13533 /* Change window state from mapped to iconified. */
13536 x_iconify_frame (f
)
13542 /* Don't keep the highlight on an invisible frame. */
13543 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
13544 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
13546 if (f
->async_iconified
)
13551 FRAME_SAMPLE_VISIBILITY (f
);
13553 type
= x_icon_type (f
);
13555 x_bitmap_icon (f
, type
);
13557 #ifdef USE_X_TOOLKIT
13559 if (! FRAME_VISIBLE_P (f
))
13561 if (! EQ (Vx_no_window_manager
, Qt
))
13562 x_wm_set_window_state (f
, IconicState
);
13563 /* This was XtPopup, but that did nothing for an iconified frame. */
13564 XtMapWidget (f
->output_data
.x
->widget
);
13565 /* The server won't give us any event to indicate
13566 that an invisible frame was changed to an icon,
13567 so we have to record it here. */
13570 f
->async_iconified
= 1;
13571 f
->async_visible
= 0;
13576 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
13577 XtWindow (f
->output_data
.x
->widget
),
13578 DefaultScreen (FRAME_X_DISPLAY (f
)));
13582 error ("Can't notify window manager of iconification");
13584 f
->async_iconified
= 1;
13585 f
->async_visible
= 0;
13589 XFlush (FRAME_X_DISPLAY (f
));
13591 #else /* not USE_X_TOOLKIT */
13593 /* Make sure the X server knows where the window should be positioned,
13594 in case the user deiconifies with the window manager. */
13595 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
13596 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
13598 /* Since we don't know which revision of X we're running, we'll use both
13599 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
13601 /* X11R4: send a ClientMessage to the window manager using the
13602 WM_CHANGE_STATE type. */
13606 message
.xclient
.window
= FRAME_X_WINDOW (f
);
13607 message
.xclient
.type
= ClientMessage
;
13608 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
13609 message
.xclient
.format
= 32;
13610 message
.xclient
.data
.l
[0] = IconicState
;
13612 if (! XSendEvent (FRAME_X_DISPLAY (f
),
13613 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
13615 SubstructureRedirectMask
| SubstructureNotifyMask
,
13618 UNBLOCK_INPUT_RESIGNAL
;
13619 error ("Can't notify window manager of iconification");
13623 /* X11R3: set the initial_state field of the window manager hints to
13625 x_wm_set_window_state (f
, IconicState
);
13627 if (!FRAME_VISIBLE_P (f
))
13629 /* If the frame was withdrawn, before, we must map it. */
13630 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13633 f
->async_iconified
= 1;
13634 f
->async_visible
= 0;
13636 XFlush (FRAME_X_DISPLAY (f
));
13638 #endif /* not USE_X_TOOLKIT */
13642 /* Free X resources of frame F. */
13645 x_free_frame_resources (f
)
13648 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13650 struct scroll_bar
*b
;
13654 /* If a display connection is dead, don't try sending more
13655 commands to the X server. */
13656 if (dpyinfo
->display
)
13658 if (f
->output_data
.x
->icon_desc
)
13659 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
13661 #ifdef USE_X_TOOLKIT
13662 /* Explicitly destroy the scroll bars of the frame. Without
13663 this, we get "BadDrawable" errors from the toolkit later on,
13664 presumably from expose events generated for the disappearing
13665 toolkit scroll bars. */
13666 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
13668 b
= XSCROLL_BAR (bar
);
13669 x_scroll_bar_remove (b
);
13675 free_frame_xic (f
);
13678 #ifdef USE_X_TOOLKIT
13679 if (f
->output_data
.x
->widget
)
13681 XtDestroyWidget (f
->output_data
.x
->widget
);
13682 f
->output_data
.x
->widget
= NULL
;
13684 /* Tooltips don't have widgets, only a simple X window, even if
13685 we are using a toolkit. */
13686 else if (FRAME_X_WINDOW (f
))
13687 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13689 free_frame_menubar (f
);
13690 #else /* !USE_X_TOOLKIT */
13691 if (FRAME_X_WINDOW (f
))
13692 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
13693 #endif /* !USE_X_TOOLKIT */
13695 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
13696 unload_color (f
, f
->output_data
.x
->background_pixel
);
13697 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
13698 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
13699 unload_color (f
, f
->output_data
.x
->border_pixel
);
13700 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
13702 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
13703 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
13704 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
13705 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
13706 #ifdef USE_TOOLKIT_SCROLL_BARS
13707 /* Scrollbar shadow colors. */
13708 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
13709 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
13710 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
13711 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
13712 #endif /* USE_TOOLKIT_SCROLL_BARS */
13713 if (f
->output_data
.x
->white_relief
.allocated_p
)
13714 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
13715 if (f
->output_data
.x
->black_relief
.allocated_p
)
13716 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
13718 if (FRAME_FACE_CACHE (f
))
13719 free_frame_faces (f
);
13722 XFlush (FRAME_X_DISPLAY (f
));
13725 if (f
->output_data
.x
->saved_menu_event
)
13726 xfree (f
->output_data
.x
->saved_menu_event
);
13728 xfree (f
->output_data
.x
);
13729 f
->output_data
.x
= NULL
;
13731 if (f
== dpyinfo
->x_focus_frame
)
13732 dpyinfo
->x_focus_frame
= 0;
13733 if (f
== dpyinfo
->x_focus_event_frame
)
13734 dpyinfo
->x_focus_event_frame
= 0;
13735 if (f
== dpyinfo
->x_highlight_frame
)
13736 dpyinfo
->x_highlight_frame
= 0;
13738 if (f
== dpyinfo
->mouse_face_mouse_frame
)
13740 dpyinfo
->mouse_face_beg_row
13741 = dpyinfo
->mouse_face_beg_col
= -1;
13742 dpyinfo
->mouse_face_end_row
13743 = dpyinfo
->mouse_face_end_col
= -1;
13744 dpyinfo
->mouse_face_window
= Qnil
;
13745 dpyinfo
->mouse_face_deferred_gc
= 0;
13746 dpyinfo
->mouse_face_mouse_frame
= 0;
13753 /* Destroy the X window of frame F. */
13756 x_destroy_window (f
)
13759 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13761 /* If a display connection is dead, don't try sending more
13762 commands to the X server. */
13763 if (dpyinfo
->display
!= 0)
13764 x_free_frame_resources (f
);
13766 dpyinfo
->reference_count
--;
13770 /* Setting window manager hints. */
13772 /* Set the normal size hints for the window manager, for frame F.
13773 FLAGS is the flags word to use--or 0 meaning preserve the flags
13774 that the window now has.
13775 If USER_POSITION is nonzero, we set the USPosition
13776 flag (this is useful when FLAGS is 0). */
13779 x_wm_set_size_hint (f
, flags
, user_position
)
13784 XSizeHints size_hints
;
13786 #ifdef USE_X_TOOLKIT
13789 Dimension widget_width
, widget_height
;
13790 Window window
= XtWindow (f
->output_data
.x
->widget
);
13791 #else /* not USE_X_TOOLKIT */
13792 Window window
= FRAME_X_WINDOW (f
);
13793 #endif /* not USE_X_TOOLKIT */
13795 /* Setting PMaxSize caused various problems. */
13796 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
13798 size_hints
.x
= f
->output_data
.x
->left_pos
;
13799 size_hints
.y
= f
->output_data
.x
->top_pos
;
13801 #ifdef USE_X_TOOLKIT
13802 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
13803 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
13804 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
13805 size_hints
.height
= widget_height
;
13806 size_hints
.width
= widget_width
;
13807 #else /* not USE_X_TOOLKIT */
13808 size_hints
.height
= PIXEL_HEIGHT (f
);
13809 size_hints
.width
= PIXEL_WIDTH (f
);
13810 #endif /* not USE_X_TOOLKIT */
13812 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
13813 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
13814 size_hints
.max_width
13815 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
13816 size_hints
.max_height
13817 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
13819 /* Calculate the base and minimum sizes.
13821 (When we use the X toolkit, we don't do it here.
13822 Instead we copy the values that the widgets are using, below.) */
13823 #ifndef USE_X_TOOLKIT
13825 int base_width
, base_height
;
13826 int min_rows
= 0, min_cols
= 0;
13828 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
13829 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
13831 check_frame_size (f
, &min_rows
, &min_cols
);
13833 /* The window manager uses the base width hints to calculate the
13834 current number of rows and columns in the frame while
13835 resizing; min_width and min_height aren't useful for this
13836 purpose, since they might not give the dimensions for a
13837 zero-row, zero-column frame.
13839 We use the base_width and base_height members if we have
13840 them; otherwise, we set the min_width and min_height members
13841 to the size for a zero x zero frame. */
13844 size_hints
.flags
|= PBaseSize
;
13845 size_hints
.base_width
= base_width
;
13846 size_hints
.base_height
= base_height
;
13847 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
13848 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
13850 size_hints
.min_width
= base_width
;
13851 size_hints
.min_height
= base_height
;
13855 /* If we don't need the old flags, we don't need the old hint at all. */
13858 size_hints
.flags
|= flags
;
13861 #endif /* not USE_X_TOOLKIT */
13864 XSizeHints hints
; /* Sometimes I hate X Windows... */
13865 long supplied_return
;
13869 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
13872 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
13875 #ifdef USE_X_TOOLKIT
13876 size_hints
.base_height
= hints
.base_height
;
13877 size_hints
.base_width
= hints
.base_width
;
13878 size_hints
.min_height
= hints
.min_height
;
13879 size_hints
.min_width
= hints
.min_width
;
13883 size_hints
.flags
|= flags
;
13888 if (hints
.flags
& PSize
)
13889 size_hints
.flags
|= PSize
;
13890 if (hints
.flags
& PPosition
)
13891 size_hints
.flags
|= PPosition
;
13892 if (hints
.flags
& USPosition
)
13893 size_hints
.flags
|= USPosition
;
13894 if (hints
.flags
& USSize
)
13895 size_hints
.flags
|= USSize
;
13899 #ifndef USE_X_TOOLKIT
13904 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
13905 size_hints
.flags
|= PWinGravity
;
13909 size_hints
.flags
&= ~ PPosition
;
13910 size_hints
.flags
|= USPosition
;
13912 #endif /* PWinGravity */
13915 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
13917 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
13921 /* Used for IconicState or NormalState */
13924 x_wm_set_window_state (f
, state
)
13928 #ifdef USE_X_TOOLKIT
13931 XtSetArg (al
[0], XtNinitialState
, state
);
13932 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
13933 #else /* not USE_X_TOOLKIT */
13934 Window window
= FRAME_X_WINDOW (f
);
13936 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
13937 f
->output_data
.x
->wm_hints
.initial_state
= state
;
13939 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
13940 #endif /* not USE_X_TOOLKIT */
13944 x_wm_set_icon_pixmap (f
, pixmap_id
)
13948 Pixmap icon_pixmap
;
13950 #ifndef USE_X_TOOLKIT
13951 Window window
= FRAME_X_WINDOW (f
);
13956 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
13957 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
13961 /* It seems there is no way to turn off use of an icon pixmap.
13962 The following line does it, only if no icon has yet been created,
13963 for some window managers. But with mwm it crashes.
13964 Some people say it should clear the IconPixmapHint bit in this case,
13965 but that doesn't work, and the X consortium said it isn't the
13966 right thing at all. Since there is no way to win,
13967 best to explicitly give up. */
13969 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
13975 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
13979 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
13980 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
13983 #else /* not USE_X_TOOLKIT */
13985 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
13986 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
13988 #endif /* not USE_X_TOOLKIT */
13992 x_wm_set_icon_position (f
, icon_x
, icon_y
)
13994 int icon_x
, icon_y
;
13996 #ifdef USE_X_TOOLKIT
13997 Window window
= XtWindow (f
->output_data
.x
->widget
);
13999 Window window
= FRAME_X_WINDOW (f
);
14002 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
14003 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
14004 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
14006 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
14010 /***********************************************************************
14012 ***********************************************************************/
14014 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
14017 x_get_font_info (f
, font_idx
)
14021 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
14025 /* Return a list of names of available fonts matching PATTERN on frame F.
14027 If SIZE is > 0, it is the size (maximum bounds width) of fonts
14030 SIZE < 0 means include scalable fonts.
14032 Frame F null means we have not yet created any frame on X, and
14033 consult the first display in x_display_list. MAXNAMES sets a limit
14034 on how many fonts to match. */
14037 x_list_fonts (f
, pattern
, size
, maxnames
)
14039 Lisp_Object pattern
;
14043 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
14044 Lisp_Object tem
, second_best
;
14045 struct x_display_info
*dpyinfo
14046 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
14047 Display
*dpy
= dpyinfo
->display
;
14048 int try_XLoadQueryFont
= 0;
14050 int allow_scalable_fonts_p
= 0;
14054 allow_scalable_fonts_p
= 1;
14058 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
14059 if (NILP (patterns
))
14060 patterns
= Fcons (pattern
, Qnil
);
14062 if (maxnames
== 1 && !size
)
14063 /* We can return any single font matching PATTERN. */
14064 try_XLoadQueryFont
= 1;
14066 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
14069 char **names
= NULL
;
14071 pattern
= XCAR (patterns
);
14072 /* See if we cached the result for this particular query.
14073 The cache is an alist of the form:
14074 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
14075 tem
= XCDR (dpyinfo
->name_list_element
);
14076 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
14077 allow_scalable_fonts_p
? Qt
: Qnil
);
14078 list
= Fassoc (key
, tem
);
14081 list
= Fcdr_safe (list
);
14082 /* We have a cashed list. Don't have to get the list again. */
14086 /* At first, put PATTERN in the cache. */
14089 count
= x_catch_errors (dpy
);
14091 if (try_XLoadQueryFont
)
14094 unsigned long value
;
14096 font
= XLoadQueryFont (dpy
, SDATA (pattern
));
14097 if (x_had_errors_p (dpy
))
14099 /* This error is perhaps due to insufficient memory on X
14100 server. Let's just ignore it. */
14102 x_clear_errors (dpy
);
14106 && XGetFontProperty (font
, XA_FONT
, &value
))
14108 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
14109 int len
= strlen (name
);
14112 /* If DXPC (a Differential X Protocol Compressor)
14113 Ver.3.7 is running, XGetAtomName will return null
14114 string. We must avoid such a name. */
14116 try_XLoadQueryFont
= 0;
14120 names
= (char **) alloca (sizeof (char *));
14121 /* Some systems only allow alloca assigned to a
14123 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
14124 bcopy (name
, names
[0], len
+ 1);
14129 try_XLoadQueryFont
= 0;
14132 XFreeFont (dpy
, font
);
14135 if (!try_XLoadQueryFont
)
14137 /* We try at least 10 fonts because XListFonts will return
14138 auto-scaled fonts at the head. */
14139 names
= XListFonts (dpy
, SDATA (pattern
), max (maxnames
, 10),
14141 if (x_had_errors_p (dpy
))
14143 /* This error is perhaps due to insufficient memory on X
14144 server. Let's just ignore it. */
14146 x_clear_errors (dpy
);
14150 x_uncatch_errors (dpy
, count
);
14157 /* Make a list of all the fonts we got back.
14158 Store that in the font cache for the display. */
14159 for (i
= 0; i
< num_fonts
; i
++)
14162 char *p
= names
[i
];
14163 int average_width
= -1, dashes
= 0;
14165 /* Count the number of dashes in NAMES[I]. If there are
14166 14 dashes, and the field value following 12th dash
14167 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
14168 is usually too ugly to be used for editing. Let's
14174 if (dashes
== 7) /* PIXEL_SIZE field */
14176 else if (dashes
== 12) /* AVERAGE_WIDTH field */
14177 average_width
= atoi (p
);
14180 if (allow_scalable_fonts_p
14181 || dashes
< 14 || average_width
!= 0)
14183 tem
= build_string (names
[i
]);
14184 if (NILP (Fassoc (tem
, list
)))
14186 if (STRINGP (Vx_pixel_size_width_font_regexp
)
14187 && ((fast_c_string_match_ignore_case
14188 (Vx_pixel_size_width_font_regexp
, names
[i
]))
14190 /* We can set the value of PIXEL_SIZE to the
14191 width of this font. */
14192 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
14194 /* For the moment, width is not known. */
14195 list
= Fcons (Fcons (tem
, Qnil
), list
);
14200 if (!try_XLoadQueryFont
)
14203 XFreeFontNames (names
);
14208 /* Now store the result in the cache. */
14209 XSETCDR (dpyinfo
->name_list_element
,
14210 Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
)));
14213 if (NILP (list
)) continue; /* Try the remaining alternatives. */
14215 newlist
= second_best
= Qnil
;
14216 /* Make a list of the fonts that have the right width. */
14217 for (; CONSP (list
); list
= XCDR (list
))
14223 if (!CONSP (tem
) || NILP (XCAR (tem
)))
14227 newlist
= Fcons (XCAR (tem
), newlist
);
14231 if (!INTEGERP (XCDR (tem
)))
14233 /* Since we have not yet known the size of this font, we
14234 must try slow function call XLoadQueryFont. */
14235 XFontStruct
*thisinfo
;
14238 count
= x_catch_errors (dpy
);
14239 thisinfo
= XLoadQueryFont (dpy
,
14240 SDATA (XCAR (tem
)));
14241 if (x_had_errors_p (dpy
))
14243 /* This error is perhaps due to insufficient memory on X
14244 server. Let's just ignore it. */
14246 x_clear_errors (dpy
);
14248 x_uncatch_errors (dpy
, count
);
14254 (thisinfo
->min_bounds
.width
== 0
14256 : make_number (thisinfo
->max_bounds
.width
)));
14258 XFreeFont (dpy
, thisinfo
);
14262 /* For unknown reason, the previous call of XListFont had
14263 returned a font which can't be opened. Record the size
14264 as 0 not to try to open it again. */
14265 XSETCDR (tem
, make_number (0));
14268 found_size
= XINT (XCDR (tem
));
14269 if (found_size
== size
)
14270 newlist
= Fcons (XCAR (tem
), newlist
);
14271 else if (found_size
> 0)
14273 if (NILP (second_best
))
14275 else if (found_size
< size
)
14277 if (XINT (XCDR (second_best
)) > size
14278 || XINT (XCDR (second_best
)) < found_size
)
14283 if (XINT (XCDR (second_best
)) > size
14284 && XINT (XCDR (second_best
)) > found_size
)
14289 if (!NILP (newlist
))
14291 else if (!NILP (second_best
))
14293 newlist
= Fcons (XCAR (second_best
), Qnil
);
14304 /* Check that FONT is valid on frame F. It is if it can be found in F's
14308 x_check_font (f
, font
)
14313 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
14315 xassert (font
!= NULL
);
14317 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
14318 if (dpyinfo
->font_table
[i
].name
14319 && font
== dpyinfo
->font_table
[i
].font
)
14322 xassert (i
< dpyinfo
->n_fonts
);
14325 #endif /* GLYPH_DEBUG != 0 */
14327 /* Set *W to the minimum width, *H to the minimum font height of FONT.
14328 Note: There are (broken) X fonts out there with invalid XFontStruct
14329 min_bounds contents. For example, handa@etl.go.jp reports that
14330 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
14331 have font->min_bounds.width == 0. */
14334 x_font_min_bounds (font
, w
, h
)
14338 *h
= FONT_HEIGHT (font
);
14339 *w
= font
->min_bounds
.width
;
14341 /* Try to handle the case where FONT->min_bounds has invalid
14342 contents. Since the only font known to have invalid min_bounds
14343 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
14345 *w
= font
->max_bounds
.width
;
14349 /* Compute the smallest character width and smallest font height over
14350 all fonts available on frame F. Set the members smallest_char_width
14351 and smallest_font_height in F's x_display_info structure to
14352 the values computed. Value is non-zero if smallest_font_height or
14353 smallest_char_width become smaller than they were before. */
14356 x_compute_min_glyph_bounds (f
)
14360 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
14362 int old_width
= dpyinfo
->smallest_char_width
;
14363 int old_height
= dpyinfo
->smallest_font_height
;
14365 dpyinfo
->smallest_font_height
= 100000;
14366 dpyinfo
->smallest_char_width
= 100000;
14368 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
14369 if (dpyinfo
->font_table
[i
].name
)
14371 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
14374 font
= (XFontStruct
*) fontp
->font
;
14375 xassert (font
!= (XFontStruct
*) ~0);
14376 x_font_min_bounds (font
, &w
, &h
);
14378 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
14379 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
14382 xassert (dpyinfo
->smallest_char_width
> 0
14383 && dpyinfo
->smallest_font_height
> 0);
14385 return (dpyinfo
->n_fonts
== 1
14386 || dpyinfo
->smallest_char_width
< old_width
14387 || dpyinfo
->smallest_font_height
< old_height
);
14391 /* Load font named FONTNAME of the size SIZE for frame F, and return a
14392 pointer to the structure font_info while allocating it dynamically.
14393 If SIZE is 0, load any size of font.
14394 If loading is failed, return NULL. */
14397 x_load_font (f
, fontname
, size
)
14399 register char *fontname
;
14402 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
14403 Lisp_Object font_names
;
14406 /* Get a list of all the fonts that match this name. Once we
14407 have a list of matching fonts, we compare them against the fonts
14408 we already have by comparing names. */
14409 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
14411 if (!NILP (font_names
))
14416 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
14417 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
14418 if (dpyinfo
->font_table
[i
].name
14419 && (!strcmp (dpyinfo
->font_table
[i
].name
,
14420 SDATA (XCAR (tail
)))
14421 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
14422 SDATA (XCAR (tail
)))))
14423 return (dpyinfo
->font_table
+ i
);
14426 /* Load the font and add it to the table. */
14430 struct font_info
*fontp
;
14431 unsigned long value
;
14434 /* If we have found fonts by x_list_font, load one of them. If
14435 not, we still try to load a font by the name given as FONTNAME
14436 because XListFonts (called in x_list_font) of some X server has
14437 a bug of not finding a font even if the font surely exists and
14438 is loadable by XLoadQueryFont. */
14439 if (size
> 0 && !NILP (font_names
))
14440 fontname
= (char *) SDATA (XCAR (font_names
));
14443 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
14444 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
14445 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
14447 /* This error is perhaps due to insufficient memory on X
14448 server. Let's just ignore it. */
14450 x_clear_errors (FRAME_X_DISPLAY (f
));
14452 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
14457 /* Find a free slot in the font table. */
14458 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
14459 if (dpyinfo
->font_table
[i
].name
== NULL
)
14462 /* If no free slot found, maybe enlarge the font table. */
14463 if (i
== dpyinfo
->n_fonts
14464 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
14467 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
14468 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
14469 dpyinfo
->font_table
14470 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
14473 fontp
= dpyinfo
->font_table
+ i
;
14474 if (i
== dpyinfo
->n_fonts
)
14475 ++dpyinfo
->n_fonts
;
14477 /* Now fill in the slots of *FONTP. */
14479 fontp
->font
= font
;
14480 fontp
->font_idx
= i
;
14481 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
14482 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
14484 /* Try to get the full name of FONT. Put it in FULL_NAME. */
14486 if (XGetFontProperty (font
, XA_FONT
, &value
))
14488 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
14492 /* Count the number of dashes in the "full name".
14493 If it is too few, this isn't really the font's full name,
14495 In X11R4, the fonts did not come with their canonical names
14506 full_name
= (char *) xmalloc (p
- name
+ 1);
14507 bcopy (name
, full_name
, p
- name
+ 1);
14513 if (full_name
!= 0)
14514 fontp
->full_name
= full_name
;
14516 fontp
->full_name
= fontp
->name
;
14518 fontp
->size
= font
->max_bounds
.width
;
14519 fontp
->height
= FONT_HEIGHT (font
);
14521 if (NILP (font_names
))
14523 /* We come here because of a bug of XListFonts mentioned at
14524 the head of this block. Let's store this information in
14525 the cache for x_list_fonts. */
14526 Lisp_Object lispy_name
= build_string (fontname
);
14527 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
14528 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
14531 XSETCDR (dpyinfo
->name_list_element
,
14533 Fcons (Fcons (lispy_full_name
,
14534 make_number (fontp
->size
)),
14536 XCDR (dpyinfo
->name_list_element
)));
14539 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
14541 XSETCDR (dpyinfo
->name_list_element
,
14543 Fcons (Fcons (lispy_full_name
,
14544 make_number (fontp
->size
)),
14546 XCDR (dpyinfo
->name_list_element
)));
14550 /* The slot `encoding' specifies how to map a character
14551 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
14552 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
14553 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
14554 2:0xA020..0xFF7F). For the moment, we don't know which charset
14555 uses this font. So, we set information in fontp->encoding[1]
14556 which is never used by any charset. If mapping can't be
14557 decided, set FONT_ENCODING_NOT_DECIDED. */
14559 = (font
->max_byte1
== 0
14561 ? (font
->min_char_or_byte2
< 0x80
14562 ? (font
->max_char_or_byte2
< 0x80
14563 ? 0 /* 0x20..0x7F */
14564 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
14565 : 1) /* 0xA0..0xFF */
14567 : (font
->min_byte1
< 0x80
14568 ? (font
->max_byte1
< 0x80
14569 ? (font
->min_char_or_byte2
< 0x80
14570 ? (font
->max_char_or_byte2
< 0x80
14571 ? 0 /* 0x2020..0x7F7F */
14572 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
14573 : 3) /* 0x20A0..0x7FFF */
14574 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
14575 : (font
->min_char_or_byte2
< 0x80
14576 ? (font
->max_char_or_byte2
< 0x80
14577 ? 2 /* 0xA020..0xFF7F */
14578 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
14579 : 1))); /* 0xA0A0..0xFFFF */
14581 fontp
->baseline_offset
14582 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
14583 ? (long) value
: 0);
14584 fontp
->relative_compose
14585 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
14586 ? (long) value
: 0);
14587 fontp
->default_ascent
14588 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
14589 ? (long) value
: 0);
14591 /* Set global flag fonts_changed_p to non-zero if the font loaded
14592 has a character with a smaller width than any other character
14593 before, or if the font loaded has a smaller height than any
14594 other font loaded before. If this happens, it will make a
14595 glyph matrix reallocation necessary. */
14596 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
14603 /* Return a pointer to struct font_info of a font named FONTNAME for
14604 frame F. If no such font is loaded, return NULL. */
14607 x_query_font (f
, fontname
)
14609 register char *fontname
;
14611 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
14614 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
14615 if (dpyinfo
->font_table
[i
].name
14616 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
14617 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
14618 return (dpyinfo
->font_table
+ i
);
14623 /* Find a CCL program for a font specified by FONTP, and set the member
14624 `encoder' of the structure. */
14627 x_find_ccl_program (fontp
)
14628 struct font_info
*fontp
;
14630 Lisp_Object list
, elt
;
14633 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
14637 && STRINGP (XCAR (elt
))
14638 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
14640 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
14647 struct ccl_program
*ccl
14648 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
14650 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
14653 fontp
->font_encoder
= ccl
;
14659 /***********************************************************************
14661 ***********************************************************************/
14663 #ifdef USE_X_TOOLKIT
14664 static XrmOptionDescRec emacs_options
[] = {
14665 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
14666 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
14668 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
14669 XrmoptionSepArg
, NULL
},
14670 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
14672 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
14673 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
14674 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
14675 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
14676 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
14677 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
14678 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
14680 #endif /* USE_X_TOOLKIT */
14682 static int x_initialized
;
14684 #ifdef MULTI_KBOARD
14685 /* Test whether two display-name strings agree up to the dot that separates
14686 the screen number from the server number. */
14688 same_x_server (name1
, name2
)
14689 const char *name1
, *name2
;
14691 int seen_colon
= 0;
14692 const unsigned char *system_name
= SDATA (Vsystem_name
);
14693 int system_name_length
= strlen (system_name
);
14694 int length_until_period
= 0;
14696 while (system_name
[length_until_period
] != 0
14697 && system_name
[length_until_period
] != '.')
14698 length_until_period
++;
14700 /* Treat `unix' like an empty host name. */
14701 if (! strncmp (name1
, "unix:", 5))
14703 if (! strncmp (name2
, "unix:", 5))
14705 /* Treat this host's name like an empty host name. */
14706 if (! strncmp (name1
, system_name
, system_name_length
)
14707 && name1
[system_name_length
] == ':')
14708 name1
+= system_name_length
;
14709 if (! strncmp (name2
, system_name
, system_name_length
)
14710 && name2
[system_name_length
] == ':')
14711 name2
+= system_name_length
;
14712 /* Treat this host's domainless name like an empty host name. */
14713 if (! strncmp (name1
, system_name
, length_until_period
)
14714 && name1
[length_until_period
] == ':')
14715 name1
+= length_until_period
;
14716 if (! strncmp (name2
, system_name
, length_until_period
)
14717 && name2
[length_until_period
] == ':')
14718 name2
+= length_until_period
;
14720 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
14724 if (seen_colon
&& *name1
== '.')
14728 && (*name1
== '.' || *name1
== '\0')
14729 && (*name2
== '.' || *name2
== '\0'));
14733 struct x_display_info
*
14734 x_term_init (display_name
, xrm_option
, resource_name
)
14735 Lisp_Object display_name
;
14737 char *resource_name
;
14741 struct x_display_info
*dpyinfo
;
14746 if (!x_initialized
)
14752 #ifdef USE_X_TOOLKIT
14753 /* weiner@footloose.sps.mot.com reports that this causes
14755 X protocol error: BadAtom (invalid Atom parameter)
14756 on protocol request 18skiloaf.
14757 So let's not use it until R6. */
14758 #ifdef HAVE_X11XTR6
14759 XtSetLanguageProc (NULL
, NULL
, NULL
);
14770 argv
[argc
++] = "-xrm";
14771 argv
[argc
++] = xrm_option
;
14774 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
14775 resource_name
, EMACS_CLASS
,
14776 emacs_options
, XtNumber (emacs_options
),
14780 #ifdef HAVE_X11XTR6
14781 /* I think this is to compensate for XtSetLanguageProc. */
14786 #else /* not USE_X_TOOLKIT */
14788 XSetLocaleModifiers ("");
14790 dpy
= XOpenDisplay (SDATA (display_name
));
14791 #endif /* not USE_X_TOOLKIT */
14793 /* Detect failure. */
14800 /* We have definitely succeeded. Record the new connection. */
14802 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
14803 bzero (dpyinfo
, sizeof *dpyinfo
);
14805 #ifdef MULTI_KBOARD
14807 struct x_display_info
*share
;
14810 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
14811 share
= share
->next
, tail
= XCDR (tail
))
14812 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
14813 SDATA (display_name
)))
14816 dpyinfo
->kboard
= share
->kboard
;
14819 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
14820 init_kboard (dpyinfo
->kboard
);
14821 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
14823 char *vendor
= ServerVendor (dpy
);
14825 dpyinfo
->kboard
->Vsystem_key_alist
14826 = call1 (Qvendor_specific_keysyms
,
14827 build_string (vendor
? vendor
: ""));
14831 dpyinfo
->kboard
->next_kboard
= all_kboards
;
14832 all_kboards
= dpyinfo
->kboard
;
14833 /* Don't let the initial kboard remain current longer than necessary.
14834 That would cause problems if a file loaded on startup tries to
14835 prompt in the mini-buffer. */
14836 if (current_kboard
== initial_kboard
)
14837 current_kboard
= dpyinfo
->kboard
;
14839 dpyinfo
->kboard
->reference_count
++;
14843 /* Put this display on the chain. */
14844 dpyinfo
->next
= x_display_list
;
14845 x_display_list
= dpyinfo
;
14847 /* Put it on x_display_name_list as well, to keep them parallel. */
14848 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
14849 x_display_name_list
);
14850 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
14852 dpyinfo
->display
= dpy
;
14855 XSetAfterFunction (x_current_display
, x_trace_wire
);
14859 = (char *) xmalloc (SBYTES (Vinvocation_name
)
14860 + SBYTES (Vsystem_name
)
14862 sprintf (dpyinfo
->x_id_name
, "%s@%s",
14863 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
14865 /* Figure out which modifier bits mean what. */
14866 x_find_modifier_meanings (dpyinfo
);
14868 /* Get the scroll bar cursor. */
14869 dpyinfo
->vertical_scroll_bar_cursor
14870 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
14872 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
14873 resource_name
, EMACS_CLASS
);
14874 #ifdef HAVE_XRMSETDATABASE
14875 XrmSetDatabase (dpyinfo
->display
, xrdb
);
14877 dpyinfo
->display
->db
= xrdb
;
14879 /* Put the rdb where we can find it in a way that works on
14881 dpyinfo
->xrdb
= xrdb
;
14883 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
14884 DefaultScreen (dpyinfo
->display
));
14885 select_visual (dpyinfo
);
14886 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
14887 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
14888 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
14889 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
14890 dpyinfo
->grabbed
= 0;
14891 dpyinfo
->reference_count
= 0;
14892 dpyinfo
->icon_bitmap_id
= -1;
14893 dpyinfo
->font_table
= NULL
;
14894 dpyinfo
->n_fonts
= 0;
14895 dpyinfo
->font_table_size
= 0;
14896 dpyinfo
->bitmaps
= 0;
14897 dpyinfo
->bitmaps_size
= 0;
14898 dpyinfo
->bitmaps_last
= 0;
14899 dpyinfo
->scratch_cursor_gc
= 0;
14900 dpyinfo
->mouse_face_mouse_frame
= 0;
14901 dpyinfo
->mouse_face_deferred_gc
= 0;
14902 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
14903 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
14904 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
14905 dpyinfo
->mouse_face_window
= Qnil
;
14906 dpyinfo
->mouse_face_overlay
= Qnil
;
14907 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
14908 dpyinfo
->mouse_face_defer
= 0;
14909 dpyinfo
->mouse_face_hidden
= 0;
14910 dpyinfo
->x_focus_frame
= 0;
14911 dpyinfo
->x_focus_event_frame
= 0;
14912 dpyinfo
->x_highlight_frame
= 0;
14913 dpyinfo
->image_cache
= make_image_cache ();
14915 /* See if a private colormap is requested. */
14916 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
14918 if (dpyinfo
->visual
->class == PseudoColor
)
14921 value
= display_x_get_resource (dpyinfo
,
14922 build_string ("privateColormap"),
14923 build_string ("PrivateColormap"),
14925 if (STRINGP (value
)
14926 && (!strcmp (SDATA (value
), "true")
14927 || !strcmp (SDATA (value
), "on")))
14928 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
14932 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
14933 dpyinfo
->visual
, AllocNone
);
14936 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
14937 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
14938 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
14939 dpyinfo
->resy
= pixels
* 25.4 / mm
;
14940 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
14941 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
14942 dpyinfo
->resx
= pixels
* 25.4 / mm
;
14945 dpyinfo
->Xatom_wm_protocols
14946 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
14947 dpyinfo
->Xatom_wm_take_focus
14948 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
14949 dpyinfo
->Xatom_wm_save_yourself
14950 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
14951 dpyinfo
->Xatom_wm_delete_window
14952 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
14953 dpyinfo
->Xatom_wm_change_state
14954 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
14955 dpyinfo
->Xatom_wm_configure_denied
14956 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
14957 dpyinfo
->Xatom_wm_window_moved
14958 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
14959 dpyinfo
->Xatom_editres
14960 = XInternAtom (dpyinfo
->display
, "Editres", False
);
14961 dpyinfo
->Xatom_CLIPBOARD
14962 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
14963 dpyinfo
->Xatom_TIMESTAMP
14964 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
14965 dpyinfo
->Xatom_TEXT
14966 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
14967 dpyinfo
->Xatom_COMPOUND_TEXT
14968 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
14969 dpyinfo
->Xatom_DELETE
14970 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
14971 dpyinfo
->Xatom_MULTIPLE
14972 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
14973 dpyinfo
->Xatom_INCR
14974 = XInternAtom (dpyinfo
->display
, "INCR", False
);
14975 dpyinfo
->Xatom_EMACS_TMP
14976 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
14977 dpyinfo
->Xatom_TARGETS
14978 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
14979 dpyinfo
->Xatom_NULL
14980 = XInternAtom (dpyinfo
->display
, "NULL", False
);
14981 dpyinfo
->Xatom_ATOM_PAIR
14982 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
14983 /* For properties of font. */
14984 dpyinfo
->Xatom_PIXEL_SIZE
14985 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
14986 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
14987 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
14988 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
14989 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
14990 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
14991 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
14993 /* Ghostscript support. */
14994 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
14995 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
14997 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
15000 dpyinfo
->cut_buffers_initialized
= 0;
15002 connection
= ConnectionNumber (dpyinfo
->display
);
15003 dpyinfo
->connection
= connection
;
15008 null_bits
[0] = 0x00;
15010 dpyinfo
->null_pixel
15011 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
15012 null_bits
, 1, 1, (long) 0, (long) 0,
15017 extern int gray_bitmap_width
, gray_bitmap_height
;
15018 extern char *gray_bitmap_bits
;
15020 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
15022 gray_bitmap_width
, gray_bitmap_height
,
15023 (unsigned long) 1, (unsigned long) 0, 1);
15027 xim_initialize (dpyinfo
, resource_name
);
15030 #ifdef subprocesses
15031 /* This is only needed for distinguishing keyboard and process input. */
15032 if (connection
!= 0)
15033 add_keyboard_wait_descriptor (connection
);
15036 #ifndef F_SETOWN_BUG
15038 #ifdef F_SETOWN_SOCK_NEG
15039 /* stdin is a socket here */
15040 fcntl (connection
, F_SETOWN
, -getpid ());
15041 #else /* ! defined (F_SETOWN_SOCK_NEG) */
15042 fcntl (connection
, F_SETOWN
, getpid ());
15043 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
15044 #endif /* ! defined (F_SETOWN) */
15045 #endif /* F_SETOWN_BUG */
15048 if (interrupt_input
)
15049 init_sigio (connection
);
15050 #endif /* ! defined (SIGIO) */
15053 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
15054 /* Make sure that we have a valid font for dialog boxes
15055 so that Xt does not crash. */
15057 Display
*dpy
= dpyinfo
->display
;
15058 XrmValue d
, fr
, to
;
15062 d
.addr
= (XPointer
)&dpy
;
15063 d
.size
= sizeof (Display
*);
15064 fr
.addr
= XtDefaultFont
;
15065 fr
.size
= sizeof (XtDefaultFont
);
15066 to
.size
= sizeof (Font
*);
15067 to
.addr
= (XPointer
)&font
;
15068 count
= x_catch_errors (dpy
);
15069 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
15071 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
15072 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
15073 x_uncatch_errors (dpy
, count
);
15078 /* See if we should run in synchronous mode. This is useful
15079 for debugging X code. */
15082 value
= display_x_get_resource (dpyinfo
,
15083 build_string ("synchronous"),
15084 build_string ("Synchronous"),
15086 if (STRINGP (value
)
15087 && (!strcmp (SDATA (value
), "true")
15088 || !strcmp (SDATA (value
), "on")))
15089 XSynchronize (dpyinfo
->display
, True
);
15097 /* Get rid of display DPYINFO, assuming all frames are already gone,
15098 and without sending any more commands to the X server. */
15101 x_delete_display (dpyinfo
)
15102 struct x_display_info
*dpyinfo
;
15104 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
15106 /* Discard this display from x_display_name_list and x_display_list.
15107 We can't use Fdelq because that can quit. */
15108 if (! NILP (x_display_name_list
)
15109 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
15110 x_display_name_list
= XCDR (x_display_name_list
);
15115 tail
= x_display_name_list
;
15116 while (CONSP (tail
) && CONSP (XCDR (tail
)))
15118 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
15120 XSETCDR (tail
, XCDR (XCDR (tail
)));
15123 tail
= XCDR (tail
);
15127 if (next_noop_dpyinfo
== dpyinfo
)
15128 next_noop_dpyinfo
= dpyinfo
->next
;
15130 if (x_display_list
== dpyinfo
)
15131 x_display_list
= dpyinfo
->next
;
15134 struct x_display_info
*tail
;
15136 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
15137 if (tail
->next
== dpyinfo
)
15138 tail
->next
= tail
->next
->next
;
15141 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
15142 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
15143 XrmDestroyDatabase (dpyinfo
->xrdb
);
15146 #ifdef MULTI_KBOARD
15147 if (--dpyinfo
->kboard
->reference_count
== 0)
15148 delete_kboard (dpyinfo
->kboard
);
15152 xim_close_dpy (dpyinfo
);
15155 xfree (dpyinfo
->font_table
);
15156 xfree (dpyinfo
->x_id_name
);
15157 xfree (dpyinfo
->color_cells
);
15162 /* Set up use of X before we make the first connection. */
15164 static struct redisplay_interface x_redisplay_interface
=
15169 x_clear_end_of_line
,
15171 x_after_update_window_line
,
15172 x_update_window_begin
,
15173 x_update_window_end
,
15176 x_clear_mouse_face
,
15177 x_get_glyph_overhangs
,
15178 x_fix_overlapping_area
15184 rif
= &x_redisplay_interface
;
15186 clear_frame_hook
= x_clear_frame
;
15187 ins_del_lines_hook
= x_ins_del_lines
;
15188 delete_glyphs_hook
= x_delete_glyphs
;
15189 ring_bell_hook
= XTring_bell
;
15190 reset_terminal_modes_hook
= XTreset_terminal_modes
;
15191 set_terminal_modes_hook
= XTset_terminal_modes
;
15192 update_begin_hook
= x_update_begin
;
15193 update_end_hook
= x_update_end
;
15194 set_terminal_window_hook
= XTset_terminal_window
;
15195 read_socket_hook
= XTread_socket
;
15196 frame_up_to_date_hook
= XTframe_up_to_date
;
15197 mouse_position_hook
= XTmouse_position
;
15198 frame_rehighlight_hook
= XTframe_rehighlight
;
15199 frame_raise_lower_hook
= XTframe_raise_lower
;
15200 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
15201 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
15202 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
15203 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
15204 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
15206 scroll_region_ok
= 1; /* we'll scroll partial frames */
15207 char_ins_del_ok
= 1;
15208 line_ins_del_ok
= 1; /* we'll just blt 'em */
15209 fast_clear_end_of_line
= 1; /* X does this well */
15210 memory_below_frame
= 0; /* we don't remember what scrolls
15215 last_tool_bar_item
= -1;
15216 any_help_event_p
= 0;
15218 /* Try to use interrupt input; if we can't, then start polling. */
15219 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
15221 #ifdef USE_X_TOOLKIT
15222 XtToolkitInitialize ();
15224 Xt_app_con
= XtCreateApplicationContext ();
15226 /* Register a converter from strings to pixels, which uses
15227 Emacs' color allocation infrastructure. */
15228 XtAppSetTypeConverter (Xt_app_con
,
15229 XtRString
, XtRPixel
, cvt_string_to_pixel
,
15230 cvt_string_to_pixel_args
,
15231 XtNumber (cvt_string_to_pixel_args
),
15232 XtCacheByDisplay
, cvt_pixel_dtor
);
15234 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
15236 /* Install an asynchronous timer that processes Xt timeout events
15237 every 0.1s. This is necessary because some widget sets use
15238 timeouts internally, for example the LessTif menu bar, or the
15239 Xaw3d scroll bar. When Xt timouts aren't processed, these
15240 widgets don't behave normally. */
15242 EMACS_TIME interval
;
15243 EMACS_SET_SECS_USECS (interval
, 0, 100000);
15244 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
15248 #ifdef USE_TOOLKIT_SCROLL_BARS
15249 xaw3d_arrow_scroll
= False
;
15250 xaw3d_pick_top
= True
;
15253 /* Note that there is no real way portable across R3/R4 to get the
15254 original error handler. */
15255 XSetErrorHandler (x_error_handler
);
15256 XSetIOErrorHandler (x_io_error_quitter
);
15258 /* Disable Window Change signals; they are handled by X events. */
15260 signal (SIGWINCH
, SIG_DFL
);
15261 #endif /* SIGWINCH */
15263 signal (SIGPIPE
, x_connection_signal
);
15266 x_session_initialize ();
15274 staticpro (&x_error_message_string
);
15275 x_error_message_string
= Qnil
;
15277 staticpro (&x_display_name_list
);
15278 x_display_name_list
= Qnil
;
15280 staticpro (&last_mouse_scroll_bar
);
15281 last_mouse_scroll_bar
= Qnil
;
15283 staticpro (&Qvendor_specific_keysyms
);
15284 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
15286 staticpro (&Qutf_8
);
15287 Qutf_8
= intern ("utf-8");
15288 staticpro (&Qlatin_1
);
15289 Qlatin_1
= intern ("latin-1");
15291 staticpro (&last_mouse_press_frame
);
15292 last_mouse_press_frame
= Qnil
;
15295 staticpro (&help_echo
);
15296 help_echo_object
= Qnil
;
15297 staticpro (&help_echo_object
);
15298 help_echo_window
= Qnil
;
15299 staticpro (&help_echo_window
);
15300 previous_help_echo
= Qnil
;
15301 staticpro (&previous_help_echo
);
15302 help_echo_pos
= -1;
15304 DEFVAR_BOOL ("mouse-autoselect-window", &mouse_autoselect_window
,
15305 doc
: /* *Non-nil means autoselect window with mouse pointer. */);
15306 mouse_autoselect_window
= 0;
15308 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
15309 doc
: /* *Non-nil means draw block cursor as wide as the glyph under it.
15310 For example, if a block cursor is over a tab, it will be drawn as
15311 wide as that tab on the display. */);
15312 x_stretch_cursor_p
= 0;
15314 DEFVAR_BOOL ("x-use-underline-position-properties",
15315 &x_use_underline_position_properties
,
15316 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
15317 nil means ignore them. If you encounter fonts with bogus
15318 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
15319 to 4.1, set this to nil. */);
15320 x_use_underline_position_properties
= 1;
15322 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
15323 doc
: /* What X toolkit scroll bars Emacs uses.
15324 A value of nil means Emacs doesn't use X toolkit scroll bars.
15325 Otherwise, value is a symbol describing the X toolkit. */);
15326 #ifdef USE_TOOLKIT_SCROLL_BARS
15328 Vx_toolkit_scroll_bars
= intern ("motif");
15329 #elif defined HAVE_XAW3D
15330 Vx_toolkit_scroll_bars
= intern ("xaw3d");
15332 Vx_toolkit_scroll_bars
= intern ("xaw");
15335 Vx_toolkit_scroll_bars
= Qnil
;
15338 staticpro (&last_mouse_motion_frame
);
15339 last_mouse_motion_frame
= Qnil
;
15341 Qmodifier_value
= intern ("modifier-value");
15342 Qalt
= intern ("alt");
15343 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
15344 Qhyper
= intern ("hyper");
15345 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
15346 Qmeta
= intern ("meta");
15347 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
15348 Qsuper
= intern ("super");
15349 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
15351 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
15352 doc
: /* Which keys Emacs uses for the alt modifier.
15353 This should be one of the symbols `alt', `hyper', `meta', `super'.
15354 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
15355 is nil, which is the same as `alt'. */);
15356 Vx_alt_keysym
= Qnil
;
15358 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
15359 doc
: /* Which keys Emacs uses for the hyper modifier.
15360 This should be one of the symbols `alt', `hyper', `meta', `super'.
15361 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
15362 default is nil, which is the same as `hyper'. */);
15363 Vx_hyper_keysym
= Qnil
;
15365 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
15366 doc
: /* Which keys Emacs uses for the meta modifier.
15367 This should be one of the symbols `alt', `hyper', `meta', `super'.
15368 For example, `meta' means use the Meta_L and Meta_R keysyms. The
15369 default is nil, which is the same as `meta'. */);
15370 Vx_meta_keysym
= Qnil
;
15372 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
15373 doc
: /* Which keys Emacs uses for the super modifier.
15374 This should be one of the symbols `alt', `hyper', `meta', `super'.
15375 For example, `super' means use the Super_L and Super_R keysyms. The
15376 default is nil, which is the same as `super'. */);
15377 Vx_super_keysym
= Qnil
;
15381 #endif /* HAVE_X_WINDOWS */