1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000
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"
88 #include "intervals.h"
93 #include <X11/Shell.h>
96 #ifdef HAVE_SYS_TIME_H
105 extern void free_frame_menubar
P_ ((struct frame
*));
106 extern struct frame
*x_menubar_window_to_frame
P_ ((struct x_display_info
*,
109 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
111 extern void _XEditResCheckMessages ();
112 #endif /* not NO_EDITRES */
114 /* Include toolkit specific headers for the scroll bar widget. */
116 #ifdef USE_TOOLKIT_SCROLL_BARS
117 #if defined USE_MOTIF
118 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
119 #include <Xm/ScrollBar.h>
120 #include <Xm/ScrollBarP.h>
121 #else /* !USE_MOTIF i.e. use Xaw */
124 #include <X11/Xaw3d/Simple.h>
125 #include <X11/Xaw3d/Scrollbar.h>
126 #define ARROW_SCROLLBAR
127 #include <X11/Xaw3d/ScrollbarP.h>
128 #else /* !HAVE_XAW3D */
129 #include <X11/Xaw/Simple.h>
130 #include <X11/Xaw/Scrollbar.h>
131 #endif /* !HAVE_XAW3D */
133 #define XtNpickTop "pickTop"
134 #endif /* !XtNpickTop */
135 #endif /* !USE_MOTIF */
136 #endif /* USE_TOOLKIT_SCROLL_BARS */
138 #endif /* USE_X_TOOLKIT */
140 #ifndef USE_X_TOOLKIT
141 #define x_any_window_to_frame x_window_to_frame
142 #define x_top_window_to_frame x_window_to_frame
147 #ifndef XtNinitialState
148 #define XtNinitialState "initialState"
153 #define min(a,b) ((a) < (b) ? (a) : (b))
156 #define max(a,b) ((a) > (b) ? (a) : (b))
159 #define abs(x) ((x) < 0 ? -(x) : (x))
161 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
164 /* Bitmaps for truncated lines. */
169 LEFT_TRUNCATION_BITMAP
,
170 RIGHT_TRUNCATION_BITMAP
,
171 OVERLAY_ARROW_BITMAP
,
172 CONTINUED_LINE_BITMAP
,
173 CONTINUATION_LINE_BITMAP
,
177 /* Bitmap drawn to indicate lines not displaying text if
178 `indicate-empty-lines' is non-nil. */
182 static unsigned char zv_bits
[] = {
183 0x00, 0x00, 0x1e, 0x1e, 0x1e, 0x1e, 0x00, 0x00};
185 /* An arrow like this: `<-'. */
188 #define left_height 8
189 static unsigned char left_bits
[] = {
190 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
192 /* Right truncation arrow bitmap `->'. */
194 #define right_width 8
195 #define right_height 8
196 static unsigned char right_bits
[] = {
197 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
199 /* Marker for continued lines. */
201 #define continued_width 8
202 #define continued_height 8
203 static unsigned char continued_bits
[] = {
204 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
206 /* Marker for continuation lines. */
208 #define continuation_width 8
209 #define continuation_height 8
210 static unsigned char continuation_bits
[] = {
211 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
213 /* Overlay arrow bitmap. */
219 static unsigned char ov_bits
[] = {
220 0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
222 /* A triangular arrow. */
225 static unsigned char ov_bits
[] = {
226 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
230 extern Lisp_Object Qhelp_echo
;
233 /* Non-zero means Emacs uses toolkit scroll bars. */
235 int x_toolkit_scroll_bars_p
;
237 /* If a string, XTread_socket generates an event to display that string.
238 (The display is done in read_char.) */
240 static Lisp_Object help_echo
;
241 static Lisp_Object help_echo_window
;
242 static Lisp_Object help_echo_object
;
243 static int help_echo_pos
;
245 /* Temporary variable for XTread_socket. */
247 static Lisp_Object previous_help_echo
;
249 /* Non-zero means that a HELP_EVENT has been generated since Emacs
252 static int any_help_event_p
;
254 /* Non-zero means draw block and hollow cursor as wide as the glyph
255 under it. For example, if a block cursor is over a tab, it will be
256 drawn as wide as that tab on the display. */
258 int x_stretch_cursor_p
;
260 /* This is a chain of structures for all the X displays currently in
263 struct x_display_info
*x_display_list
;
265 /* This is a list of cons cells, each of the form (NAME
266 . FONT-LIST-CACHE), one for each element of x_display_list and in
267 the same order. NAME is the name of the frame. FONT-LIST-CACHE
268 records previous values returned by x-list-fonts. */
270 Lisp_Object x_display_name_list
;
272 /* Frame being updated by update_frame. This is declared in term.c.
273 This is set by update_begin and looked at by all the XT functions.
274 It is zero while not inside an update. In that case, the XT
275 functions assume that `selected_frame' is the frame to apply to. */
277 extern struct frame
*updating_frame
;
279 extern int waiting_for_input
;
281 /* This is a frame waiting to be auto-raised, within XTread_socket. */
283 struct frame
*pending_autoraise_frame
;
286 /* The application context for Xt use. */
287 XtAppContext Xt_app_con
;
288 static String Xt_default_resources
[] = {0};
289 #endif /* USE_X_TOOLKIT */
291 /* Nominal cursor position -- where to draw output.
292 HPOS and VPOS are window relative glyph matrix coordinates.
293 X and Y are window relative pixel coordinates. */
295 struct cursor_pos output_cursor
;
297 /* Non-zero means user is interacting with a toolkit scroll bar. */
299 static int toolkit_scroll_bar_interaction
;
303 Formerly, we used PointerMotionHintMask (in standard_event_mask)
304 so that we would have to call XQueryPointer after each MotionNotify
305 event to ask for another such event. However, this made mouse tracking
306 slow, and there was a bug that made it eventually stop.
308 Simply asking for MotionNotify all the time seems to work better.
310 In order to avoid asking for motion events and then throwing most
311 of them away or busy-polling the server for mouse positions, we ask
312 the server for pointer motion hints. This means that we get only
313 one event per group of mouse movements. "Groups" are delimited by
314 other kinds of events (focus changes and button clicks, for
315 example), or by XQueryPointer calls; when one of these happens, we
316 get another MotionNotify event the next time the mouse moves. This
317 is at least as efficient as getting motion events when mouse
318 tracking is on, and I suspect only negligibly worse when tracking
321 /* Where the mouse was last time we reported a mouse event. */
323 FRAME_PTR last_mouse_frame
;
324 static XRectangle last_mouse_glyph
;
325 static Lisp_Object last_mouse_press_frame
;
327 /* The scroll bar in which the last X motion event occurred.
329 If the last X motion event occurred in a scroll bar, we set this so
330 XTmouse_position can know whether to report a scroll bar motion or
333 If the last X motion event didn't occur in a scroll bar, we set
334 this to Qnil, to tell XTmouse_position to return an ordinary motion
337 static Lisp_Object last_mouse_scroll_bar
;
339 /* This is a hack. We would really prefer that XTmouse_position would
340 return the time associated with the position it returns, but there
341 doesn't seem to be any way to wrest the time-stamp from the server
342 along with the position query. So, we just keep track of the time
343 of the last movement we received, and return that in hopes that
344 it's somewhat accurate. */
346 static Time last_mouse_movement_time
;
348 /* Incremented by XTread_socket whenever it really tries to read
352 static int volatile input_signal_count
;
354 static int input_signal_count
;
357 /* Used locally within XTread_socket. */
359 static int x_noop_count
;
361 /* Initial values of argv and argc. */
363 extern char **initial_argv
;
364 extern int initial_argc
;
366 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
368 /* Tells if a window manager is present or not. */
370 extern Lisp_Object Vx_no_window_manager
;
372 extern Lisp_Object Qface
, Qmouse_face
;
376 /* A mask of extra modifier bits to put into every keyboard char. */
378 extern int extra_keyboard_modifiers
;
380 static Lisp_Object Qvendor_specific_keysyms
;
382 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
383 extern Lisp_Object x_icon_type
P_ ((struct frame
*));
386 /* Enumeration for overriding/changing the face to use for drawing
387 glyphs in x_draw_glyphs. */
389 enum draw_glyphs_face
399 static const XColor
*x_color_cells
P_ ((struct frame
*, int *));
400 static void x_update_window_end
P_ ((struct window
*, int, int));
401 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
402 void x_delete_display
P_ ((struct x_display_info
*));
403 static unsigned int x_x_to_emacs_modifiers
P_ ((struct x_display_info
*,
405 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
407 static void set_output_cursor
P_ ((struct cursor_pos
*));
408 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
409 int *, int *, int *));
410 static void note_mode_line_highlight
P_ ((struct window
*, int, int));
411 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
412 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
413 static void x_handle_tool_bar_click
P_ ((struct frame
*, XButtonEvent
*));
414 static void show_mouse_face
P_ ((struct x_display_info
*,
415 enum draw_glyphs_face
));
416 static int x_io_error_quitter
P_ ((Display
*));
417 int x_catch_errors
P_ ((Display
*));
418 void x_uncatch_errors
P_ ((Display
*, int));
419 void x_lower_frame
P_ ((struct frame
*));
420 void x_scroll_bar_clear
P_ ((struct frame
*));
421 int x_had_errors_p
P_ ((Display
*));
422 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
423 void x_raise_frame
P_ ((struct frame
*));
424 void x_set_window_size
P_ ((struct frame
*, int, int, int));
425 void x_wm_set_window_state
P_ ((struct frame
*, int));
426 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
427 void x_initialize
P_ ((void));
428 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
429 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
430 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
432 enum draw_glyphs_face
));
433 static void x_update_end
P_ ((struct frame
*));
434 static void XTframe_up_to_date
P_ ((struct frame
*));
435 static void XTreassert_line_highlight
P_ ((int, int));
436 static void x_change_line_highlight
P_ ((int, int, int, int));
437 static void XTset_terminal_modes
P_ ((void));
438 static void XTreset_terminal_modes
P_ ((void));
439 static void XTcursor_to
P_ ((int, int, int, int));
440 static void x_write_glyphs
P_ ((struct glyph
*, int));
441 static void x_clear_end_of_line
P_ ((int));
442 static void x_clear_frame
P_ ((void));
443 static void x_clear_cursor
P_ ((struct window
*));
444 static void frame_highlight
P_ ((struct frame
*));
445 static void frame_unhighlight
P_ ((struct frame
*));
446 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
447 static void XTframe_rehighlight
P_ ((struct frame
*));
448 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
449 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
450 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int));
451 static int x_intersect_rectangles
P_ ((XRectangle
*, XRectangle
*,
453 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
454 static void expose_window_tree
P_ ((struct window
*, XRectangle
*));
455 static void expose_window
P_ ((struct window
*, XRectangle
*));
456 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
457 XRectangle
*, enum glyph_row_area
));
458 static void expose_line
P_ ((struct window
*, struct glyph_row
*,
460 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
461 static void x_update_window_cursor
P_ ((struct window
*, int));
462 static void x_erase_phys_cursor
P_ ((struct window
*));
463 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
464 static void x_draw_bitmap
P_ ((struct window
*, struct glyph_row
*,
467 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
469 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, XRectangle
*));
470 static void x_draw_row_bitmaps
P_ ((struct window
*, struct glyph_row
*));
471 static void note_overwritten_text_cursor
P_ ((struct window
*, int, int));
472 static void x_flush
P_ ((struct frame
*f
));
473 static void x_update_begin
P_ ((struct frame
*));
474 static void x_update_window_begin
P_ ((struct window
*));
475 static void x_draw_vertical_border
P_ ((struct window
*));
476 static void x_after_update_window_line
P_ ((struct glyph_row
*));
477 static INLINE
void take_vertical_position_into_account
P_ ((struct it
*));
478 static void x_produce_stretch_glyph
P_ ((struct it
*));
481 /* Flush display of frame F, or of all frames if F is null. */
490 Lisp_Object rest
, frame
;
491 FOR_EACH_FRAME (rest
, frame
)
492 x_flush (XFRAME (frame
));
494 else if (FRAME_X_P (f
))
495 XFlush (FRAME_X_DISPLAY (f
));
500 /* Remove calls to XFlush by defining XFlush to an empty replacement.
501 Calls to XFlush should be unnecessary because the X output buffer
502 is flushed automatically as needed by calls to XPending,
503 XNextEvent, or XWindowEvent according to the XFlush man page.
504 XTread_socket calls XPending. Removing XFlush improves
507 #define XFlush(DISPLAY) (void) 0
510 /***********************************************************************
512 ***********************************************************************/
516 /* This is a function useful for recording debugging information about
517 the sequence of occurrences in this file. */
525 struct record event_record
[100];
527 int event_record_index
;
529 record_event (locus
, type
)
533 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
534 event_record_index
= 0;
536 event_record
[event_record_index
].locus
= locus
;
537 event_record
[event_record_index
].type
= type
;
538 event_record_index
++;
545 /* Return the struct x_display_info corresponding to DPY. */
547 struct x_display_info
*
548 x_display_info_for_display (dpy
)
551 struct x_display_info
*dpyinfo
;
553 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
554 if (dpyinfo
->display
== dpy
)
562 /***********************************************************************
563 Starting and ending an update
564 ***********************************************************************/
566 /* Start an update of frame F. This function is installed as a hook
567 for update_begin, i.e. it is called when update_begin is called.
568 This function is called prior to calls to x_update_window_begin for
569 each window being updated. Currently, there is nothing to do here
570 because all interesting stuff is done on a window basis. */
580 /* Start update of window W. Set the global variable updated_window
581 to the window being updated and set output_cursor to the cursor
585 x_update_window_begin (w
)
588 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
589 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
592 set_output_cursor (&w
->cursor
);
596 if (f
== display_info
->mouse_face_mouse_frame
)
598 /* Don't do highlighting for mouse motion during the update. */
599 display_info
->mouse_face_defer
= 1;
601 /* If F needs to be redrawn, simply forget about any prior mouse
603 if (FRAME_GARBAGED_P (f
))
604 display_info
->mouse_face_window
= Qnil
;
606 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
607 their mouse_face_p flag set, which means that they are always
608 unequal to rows in a desired matrix which never have that
609 flag set. So, rows containing mouse-face glyphs are never
610 scrolled, and we don't have to switch the mouse highlight off
611 here to prevent it from being scrolled. */
613 /* Can we tell that this update does not affect the window
614 where the mouse highlight is? If so, no need to turn off.
615 Likewise, don't do anything if the frame is garbaged;
616 in that case, the frame's current matrix that we would use
617 is all wrong, and we will redisplay that line anyway. */
618 if (!NILP (display_info
->mouse_face_window
)
619 && w
== XWINDOW (display_info
->mouse_face_window
))
623 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
624 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
627 if (i
< w
->desired_matrix
->nrows
)
628 clear_mouse_face (display_info
);
637 /* Draw a vertical window border to the right of window W if W doesn't
638 have vertical scroll bars. */
641 x_draw_vertical_border (w
)
644 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
646 /* Redraw borders between horizontally adjacent windows. Don't
647 do it for frames with vertical scroll bars because either the
648 right scroll bar of a window, or the left scroll bar of its
649 neighbor will suffice as a border. */
650 if (!WINDOW_RIGHTMOST_P (w
)
651 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
655 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
656 x1
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
);
659 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
660 f
->output_data
.x
->normal_gc
, x1
, y0
, x1
, y1
);
665 /* End update of window W (which is equal to updated_window).
667 Draw vertical borders between horizontally adjacent windows, and
668 display W's cursor if CURSOR_ON_P is non-zero.
670 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
671 glyphs in mouse-face were overwritten. In that case we have to
672 make sure that the mouse-highlight is properly redrawn.
674 W may be a menu bar pseudo-window in case we don't have X toolkit
675 support. Such windows don't have a cursor, so don't display it
679 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
681 int cursor_on_p
, mouse_face_overwritten_p
;
683 if (!w
->pseudo_window_p
)
685 struct x_display_info
*dpyinfo
686 = FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
690 /* If a row with mouse-face was overwritten, arrange for
691 XTframe_up_to_date to redisplay the mouse highlight. */
692 if (mouse_face_overwritten_p
)
694 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
695 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
696 dpyinfo
->mouse_face_window
= Qnil
;
700 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
702 output_cursor
.x
, output_cursor
.y
);
704 x_draw_vertical_border (w
);
708 updated_window
= NULL
;
712 /* End update of frame F. This function is installed as a hook in
719 /* Mouse highlight may be displayed again. */
720 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
723 XFlush (FRAME_X_DISPLAY (f
));
728 /* This function is called from various places in xdisp.c whenever a
729 complete update has been performed. The global variable
730 updated_window is not available here. */
733 XTframe_up_to_date (f
)
738 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
740 if (dpyinfo
->mouse_face_deferred_gc
741 || f
== dpyinfo
->mouse_face_mouse_frame
)
744 if (dpyinfo
->mouse_face_mouse_frame
)
745 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
746 dpyinfo
->mouse_face_mouse_x
,
747 dpyinfo
->mouse_face_mouse_y
);
748 dpyinfo
->mouse_face_deferred_gc
= 0;
755 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
756 arrow bitmaps, or clear the areas where they would be displayed
757 before DESIRED_ROW is made current. The window being updated is
758 found in updated_window. This function It is called from
759 update_window_line only if it is known that there are differences
760 between bitmaps to be drawn between current row and DESIRED_ROW. */
763 x_after_update_window_line (desired_row
)
764 struct glyph_row
*desired_row
;
766 struct window
*w
= updated_window
;
770 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
773 x_draw_row_bitmaps (w
, desired_row
);
775 /* When a window has disappeared, make sure that no rest of
776 full-width rows stays visible in the internal border. */
777 if (windows_or_buffers_changed
)
779 struct frame
*f
= XFRAME (w
->frame
);
780 int width
= FRAME_INTERNAL_BORDER_WIDTH (f
);
781 int height
= desired_row
->visible_height
;
782 int x
= (window_box_right (w
, -1)
783 + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
));
784 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
786 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
787 x
, y
, width
, height
, False
);
795 /* Draw the bitmap WHICH in one of the areas to the left or right of
796 window W. ROW is the glyph row for which to display the bitmap; it
797 determines the vertical position at which the bitmap has to be
801 x_draw_bitmap (w
, row
, which
)
803 struct glyph_row
*row
;
804 enum bitmap_type which
;
806 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
807 Display
*display
= FRAME_X_DISPLAY (f
);
808 Window window
= FRAME_X_WINDOW (f
);
812 GC gc
= f
->output_data
.x
->normal_gc
;
814 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
816 /* Must clip because of partially visible lines. */
817 x_clip_to_row (w
, row
, gc
, 1);
821 case LEFT_TRUNCATION_BITMAP
:
825 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
827 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
830 case OVERLAY_ARROW_BITMAP
:
834 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
836 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
839 case RIGHT_TRUNCATION_BITMAP
:
843 x
= window_box_right (w
, -1);
844 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
847 case CONTINUED_LINE_BITMAP
:
850 bits
= continued_bits
;
851 x
= window_box_right (w
, -1);
852 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
855 case CONTINUATION_LINE_BITMAP
:
856 wd
= continuation_width
;
857 h
= continuation_height
;
858 bits
= continuation_bits
;
859 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
861 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
868 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
870 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
877 /* Convert to frame coordinates. Set dy to the offset in the row to
878 start drawing the bitmap. */
879 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
880 dy
= (row
->height
- h
) / 2;
882 /* Draw the bitmap. I believe these small pixmaps can be cached
884 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
885 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, wd
, h
,
887 face
->background
, depth
);
888 XCopyArea (display
, pixmap
, window
, gc
, 0, 0, wd
, h
, x
, y
+ dy
);
889 XFreePixmap (display
, pixmap
);
890 XSetClipMask (display
, gc
, None
);
894 /* Draw flags bitmaps for glyph row ROW on window W. Call this
895 function with input blocked. */
898 x_draw_row_bitmaps (w
, row
)
900 struct glyph_row
*row
;
902 struct frame
*f
= XFRAME (w
->frame
);
903 enum bitmap_type bitmap
;
905 int header_line_height
= -1;
907 xassert (interrupt_input_blocked
);
909 /* If row is completely invisible, because of vscrolling, we
910 don't have to draw anything. */
911 if (row
->visible_height
<= 0)
914 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
915 PREPARE_FACE_FOR_DISPLAY (f
, face
);
917 /* Decide which bitmap to draw at the left side. */
918 if (row
->overlay_arrow_p
)
919 bitmap
= OVERLAY_ARROW_BITMAP
;
920 else if (row
->truncated_on_left_p
)
921 bitmap
= LEFT_TRUNCATION_BITMAP
;
922 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
923 bitmap
= CONTINUATION_LINE_BITMAP
;
924 else if (row
->indicate_empty_line_p
)
925 bitmap
= ZV_LINE_BITMAP
;
929 /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
931 if (bitmap
== NO_BITMAP
932 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
933 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
935 /* If W has a vertical border to its left, don't draw over it. */
936 int border
= ((XFASTINT (w
->left
) > 0
937 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
939 int left
= window_box_left (w
, -1);
941 if (header_line_height
< 0)
942 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
944 /* In case the same realized face is used for bitmap areas and
945 for something displayed in the text (e.g. face `region' on
946 mono-displays, the fill style may have been changed to
947 FillSolid in x_draw_glyph_string_background. */
949 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
951 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
953 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
956 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
958 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
960 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - border
,
961 row
->visible_height
);
963 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
966 /* Draw the left bitmap. */
967 if (bitmap
!= NO_BITMAP
)
968 x_draw_bitmap (w
, row
, bitmap
);
970 /* Decide which bitmap to draw at the right side. */
971 if (row
->truncated_on_right_p
)
972 bitmap
= RIGHT_TRUNCATION_BITMAP
;
973 else if (row
->continued_p
)
974 bitmap
= CONTINUED_LINE_BITMAP
;
978 /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
980 if (bitmap
== NO_BITMAP
981 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
)
982 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
984 int right
= window_box_right (w
, -1);
986 if (header_line_height
< 0)
987 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
989 /* In case the same realized face is used for bitmap areas and
990 for something displayed in the text (e.g. face `region' on
991 mono-displays, the fill style may have been changed to
992 FillSolid in x_draw_glyph_string_background. */
994 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
996 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
997 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1000 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
1002 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
),
1003 row
->visible_height
);
1005 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
1008 /* Draw the right bitmap. */
1009 if (bitmap
!= NO_BITMAP
)
1010 x_draw_bitmap (w
, row
, bitmap
);
1014 /***********************************************************************
1016 ***********************************************************************/
1018 /* External interface to control of standout mode. Not used for X
1019 frames. Aborts when called. */
1022 XTreassert_line_highlight (new, vpos
)
1029 /* Call this when about to modify line at position VPOS and change
1030 whether it is highlighted. Not used for X frames. Aborts when
1034 x_change_line_highlight (new_highlight
, vpos
, y
, first_unused_hpos
)
1035 int new_highlight
, vpos
, y
, first_unused_hpos
;
1041 /* This is called when starting Emacs and when restarting after
1042 suspend. When starting Emacs, no X window is mapped. And nothing
1043 must be done to Emacs's own window if it is suspended (though that
1047 XTset_terminal_modes ()
1051 /* This is called when exiting or suspending Emacs. Exiting will make
1052 the X-windows go away, and suspending requires no action. */
1055 XTreset_terminal_modes ()
1061 /***********************************************************************
1063 ***********************************************************************/
1065 /* Set the global variable output_cursor to CURSOR. All cursor
1066 positions are relative to updated_window. */
1069 set_output_cursor (cursor
)
1070 struct cursor_pos
*cursor
;
1072 output_cursor
.hpos
= cursor
->hpos
;
1073 output_cursor
.vpos
= cursor
->vpos
;
1074 output_cursor
.x
= cursor
->x
;
1075 output_cursor
.y
= cursor
->y
;
1079 /* Set a nominal cursor position.
1081 HPOS and VPOS are column/row positions in a window glyph matrix. X
1082 and Y are window text area relative pixel positions.
1084 If this is done during an update, updated_window will contain the
1085 window that is being updated and the position is the future output
1086 cursor position for that window. If updated_window is null, use
1087 selected_window and display the cursor at the given position. */
1090 XTcursor_to (vpos
, hpos
, y
, x
)
1091 int vpos
, hpos
, y
, x
;
1095 /* If updated_window is not set, work on selected_window. */
1099 w
= XWINDOW (selected_window
);
1101 /* Set the output cursor. */
1102 output_cursor
.hpos
= hpos
;
1103 output_cursor
.vpos
= vpos
;
1104 output_cursor
.x
= x
;
1105 output_cursor
.y
= y
;
1107 /* If not called as part of an update, really display the cursor.
1108 This will also set the cursor position of W. */
1109 if (updated_window
== NULL
)
1112 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1113 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1120 /***********************************************************************
1122 ***********************************************************************/
1124 /* Function prototypes of this page. */
1126 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1130 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1131 int, XChar2b
*, int));
1132 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
1133 static void x_encode_char
P_ ((int, XChar2b
*, struct font_info
*));
1134 static void x_append_glyph
P_ ((struct it
*));
1135 static void x_append_composite_glyph
P_ ((struct it
*));
1136 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1138 static void x_produce_glyphs
P_ ((struct it
*));
1139 static void x_produce_image_glyph
P_ ((struct it
*it
));
1142 /* Return a pointer to per-char metric information in FONT of a
1143 character pointed by B which is a pointer to an XChar2b. */
1145 #define PER_CHAR_METRIC(font, b) \
1147 ? ((font)->per_char + (b)->byte2 - (font)->min_char_or_byte2 \
1148 + (((font)->min_byte1 || (font)->max_byte1) \
1149 ? (((b)->byte1 - (font)->min_byte1) \
1150 * ((font)->max_char_or_byte2 - (font)->min_char_or_byte2 + 1)) \
1152 : &((font)->max_bounds))
1155 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1156 is not contained in the font. */
1158 static INLINE XCharStruct
*
1159 x_per_char_metric (font
, char2b
)
1163 /* The result metric information. */
1164 XCharStruct
*pcm
= NULL
;
1166 xassert (font
&& char2b
);
1168 if (font
->per_char
!= NULL
)
1170 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
1172 /* min_char_or_byte2 specifies the linear character index
1173 corresponding to the first element of the per_char array,
1174 max_char_or_byte2 is the index of the last character. A
1175 character with non-zero CHAR2B->byte1 is not in the font.
1176 A character with byte2 less than min_char_or_byte2 or
1177 greater max_char_or_byte2 is not in the font. */
1178 if (char2b
->byte1
== 0
1179 && char2b
->byte2
>= font
->min_char_or_byte2
1180 && char2b
->byte2
<= font
->max_char_or_byte2
)
1181 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
1185 /* If either min_byte1 or max_byte1 are nonzero, both
1186 min_char_or_byte2 and max_char_or_byte2 are less than
1187 256, and the 2-byte character index values corresponding
1188 to the per_char array element N (counting from 0) are:
1190 byte1 = N/D + min_byte1
1191 byte2 = N\D + min_char_or_byte2
1195 D = max_char_or_byte2 - min_char_or_byte2 + 1
1196 / = integer division
1197 \ = integer modulus */
1198 if (char2b
->byte1
>= font
->min_byte1
1199 && char2b
->byte1
<= font
->max_byte1
1200 && char2b
->byte2
>= font
->min_char_or_byte2
1201 && char2b
->byte2
<= font
->max_char_or_byte2
)
1203 pcm
= (font
->per_char
1204 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
1205 * (char2b
->byte1
- font
->min_byte1
))
1206 + (char2b
->byte2
- font
->min_char_or_byte2
));
1212 /* If the per_char pointer is null, all glyphs between the first
1213 and last character indexes inclusive have the same
1214 information, as given by both min_bounds and max_bounds. */
1215 if (char2b
->byte2
>= font
->min_char_or_byte2
1216 && char2b
->byte2
<= font
->max_char_or_byte2
)
1217 pcm
= &font
->max_bounds
;
1220 return ((pcm
== NULL
1221 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
1226 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1227 the two-byte form of C. Encoding is returned in *CHAR2B. */
1230 x_encode_char (c
, char2b
, font_info
)
1233 struct font_info
*font_info
;
1235 int charset
= CHAR_CHARSET (c
);
1236 XFontStruct
*font
= font_info
->font
;
1238 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1239 This may be either a program in a special encoder language or a
1241 if (font_info
->font_encoder
)
1243 /* It's a program. */
1244 struct ccl_program
*ccl
= font_info
->font_encoder
;
1246 if (CHARSET_DIMENSION (charset
) == 1)
1248 ccl
->reg
[0] = charset
;
1249 ccl
->reg
[1] = char2b
->byte2
;
1253 ccl
->reg
[0] = charset
;
1254 ccl
->reg
[1] = char2b
->byte1
;
1255 ccl
->reg
[2] = char2b
->byte2
;
1258 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1260 /* We assume that MSBs are appropriately set/reset by CCL
1262 if (font
->max_byte1
== 0) /* 1-byte font */
1263 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
1265 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
1267 else if (font_info
->encoding
[charset
])
1269 /* Fixed encoding scheme. See fontset.h for the meaning of the
1270 encoding numbers. */
1271 int enc
= font_info
->encoding
[charset
];
1273 if ((enc
== 1 || enc
== 2)
1274 && CHARSET_DIMENSION (charset
) == 2)
1275 char2b
->byte1
|= 0x80;
1277 if (enc
== 1 || enc
== 3)
1278 char2b
->byte2
|= 0x80;
1283 /* Get face and two-byte form of character C in face FACE_ID on frame
1284 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1285 means we want to display multibyte text. Value is a pointer to a
1286 realized face that is ready for display. */
1288 static INLINE
struct face
*
1289 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
)
1295 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1299 /* Unibyte case. We don't have to encode, but we have to make
1300 sure to use a face suitable for unibyte. */
1303 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1304 face
= FACE_FROM_ID (f
, face_id
);
1306 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1308 /* Case of ASCII in a face known to fit ASCII. */
1314 int c1
, c2
, charset
;
1316 /* Split characters into bytes. If c2 is -1 afterwards, C is
1317 really a one-byte character so that byte1 is zero. */
1318 SPLIT_CHAR (c
, charset
, c1
, c2
);
1320 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1322 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1324 /* Maybe encode the character in *CHAR2B. */
1325 if (face
->font
!= NULL
)
1327 struct font_info
*font_info
1328 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1330 x_encode_char (c
, char2b
, font_info
);
1334 /* Make sure X resources of the face are allocated. */
1335 xassert (face
!= NULL
);
1336 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1342 /* Get face and two-byte form of character glyph GLYPH on frame F.
1343 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1344 a pointer to a realized face that is ready for display. */
1346 static INLINE
struct face
*
1347 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1349 struct glyph
*glyph
;
1355 xassert (glyph
->type
== CHAR_GLYPH
);
1356 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1361 if (!glyph
->multibyte_p
)
1363 /* Unibyte case. We don't have to encode, but we have to make
1364 sure to use a face suitable for unibyte. */
1366 char2b
->byte2
= glyph
->u
.ch
;
1368 else if (glyph
->u
.ch
< 128
1369 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1371 /* Case of ASCII in a face known to fit ASCII. */
1373 char2b
->byte2
= glyph
->u
.ch
;
1377 int c1
, c2
, charset
;
1379 /* Split characters into bytes. If c2 is -1 afterwards, C is
1380 really a one-byte character so that byte1 is zero. */
1381 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1383 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1385 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1387 /* Maybe encode the character in *CHAR2B. */
1388 if (charset
!= CHARSET_ASCII
)
1390 struct font_info
*font_info
1391 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1394 x_encode_char (glyph
->u
.ch
, char2b
, font_info
);
1397 = ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
1402 /* Make sure X resources of the face are allocated. */
1403 xassert (face
!= NULL
);
1404 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1409 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1410 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1416 struct glyph
*glyph
;
1417 enum glyph_row_area area
= it
->area
;
1419 xassert (it
->glyph_row
);
1420 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1422 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1423 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1425 glyph
->charpos
= CHARPOS (it
->position
);
1426 glyph
->object
= it
->object
;
1427 glyph
->pixel_width
= it
->pixel_width
;
1428 glyph
->voffset
= it
->voffset
;
1429 glyph
->type
= CHAR_GLYPH
;
1430 glyph
->multibyte_p
= it
->multibyte_p
;
1431 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1432 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1433 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1434 || it
->phys_descent
> it
->descent
);
1435 glyph
->padding_p
= 0;
1436 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1437 glyph
->face_id
= it
->face_id
;
1438 glyph
->u
.ch
= it
->char_to_display
;
1439 ++it
->glyph_row
->used
[area
];
1443 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1444 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1447 x_append_composite_glyph (it
)
1450 struct glyph
*glyph
;
1451 enum glyph_row_area area
= it
->area
;
1453 xassert (it
->glyph_row
);
1455 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1456 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1458 glyph
->charpos
= CHARPOS (it
->position
);
1459 glyph
->object
= it
->object
;
1460 glyph
->pixel_width
= it
->pixel_width
;
1461 glyph
->voffset
= it
->voffset
;
1462 glyph
->type
= COMPOSITE_GLYPH
;
1463 glyph
->multibyte_p
= it
->multibyte_p
;
1464 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1465 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1466 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1467 || it
->phys_descent
> it
->descent
);
1468 glyph
->padding_p
= 0;
1469 glyph
->glyph_not_available_p
= 0;
1470 glyph
->face_id
= it
->face_id
;
1471 glyph
->u
.cmp_id
= it
->cmp_id
;
1472 ++it
->glyph_row
->used
[area
];
1477 /* Change IT->ascent and IT->height according to the setting of
1481 take_vertical_position_into_account (it
)
1486 if (it
->voffset
< 0)
1487 /* Increase the ascent so that we can display the text higher
1489 it
->ascent
+= abs (it
->voffset
);
1491 /* Increase the descent so that we can display the text lower
1493 it
->descent
+= it
->voffset
;
1498 /* Produce glyphs/get display metrics for the image IT is loaded with.
1499 See the description of struct display_iterator in dispextern.h for
1500 an overview of struct display_iterator. */
1503 x_produce_image_glyph (it
)
1509 xassert (it
->what
== IT_IMAGE
);
1511 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1512 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1515 /* Make sure X resources of the face and image are loaded. */
1516 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1517 prepare_image_for_display (it
->f
, img
);
1519 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1520 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->margin
- it
->ascent
;
1521 it
->pixel_width
= img
->width
+ 2 * img
->margin
;
1525 if (face
->box
!= FACE_NO_BOX
)
1527 it
->ascent
+= face
->box_line_width
;
1528 it
->descent
+= face
->box_line_width
;
1530 if (it
->start_of_box_run_p
)
1531 it
->pixel_width
+= face
->box_line_width
;
1532 if (it
->end_of_box_run_p
)
1533 it
->pixel_width
+= face
->box_line_width
;
1536 take_vertical_position_into_account (it
);
1540 struct glyph
*glyph
;
1541 enum glyph_row_area area
= it
->area
;
1543 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1544 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1546 glyph
->charpos
= CHARPOS (it
->position
);
1547 glyph
->object
= it
->object
;
1548 glyph
->pixel_width
= it
->pixel_width
;
1549 glyph
->voffset
= it
->voffset
;
1550 glyph
->type
= IMAGE_GLYPH
;
1551 glyph
->multibyte_p
= it
->multibyte_p
;
1552 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1553 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1554 glyph
->overlaps_vertically_p
= 0;
1555 glyph
->padding_p
= 0;
1556 glyph
->glyph_not_available_p
= 0;
1557 glyph
->face_id
= it
->face_id
;
1558 glyph
->u
.img_id
= img
->id
;
1559 ++it
->glyph_row
->used
[area
];
1565 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1566 of the glyph, WIDTH and HEIGHT are the width and height of the
1567 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1568 ascent of the glyph (0 <= ASCENT <= 1). */
1571 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1577 struct glyph
*glyph
;
1578 enum glyph_row_area area
= it
->area
;
1580 xassert (ascent
>= 0 && ascent
<= 1);
1582 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1583 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1585 glyph
->charpos
= CHARPOS (it
->position
);
1586 glyph
->object
= object
;
1587 glyph
->pixel_width
= width
;
1588 glyph
->voffset
= it
->voffset
;
1589 glyph
->type
= STRETCH_GLYPH
;
1590 glyph
->multibyte_p
= it
->multibyte_p
;
1591 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1592 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1593 glyph
->overlaps_vertically_p
= 0;
1594 glyph
->padding_p
= 0;
1595 glyph
->glyph_not_available_p
= 0;
1596 glyph
->face_id
= it
->face_id
;
1597 glyph
->u
.stretch
.ascent
= height
* ascent
;
1598 glyph
->u
.stretch
.height
= height
;
1599 ++it
->glyph_row
->used
[area
];
1604 /* Produce a stretch glyph for iterator IT. IT->object is the value
1605 of the glyph property displayed. The value must be a list
1606 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1609 1. `:width WIDTH' specifies that the space should be WIDTH *
1610 canonical char width wide. WIDTH may be an integer or floating
1613 2. `:relative-width FACTOR' specifies that the width of the stretch
1614 should be computed from the width of the first character having the
1615 `glyph' property, and should be FACTOR times that width.
1617 3. `:align-to HPOS' specifies that the space should be wide enough
1618 to reach HPOS, a value in canonical character units.
1620 Exactly one of the above pairs must be present.
1622 4. `:height HEIGHT' specifies that the height of the stretch produced
1623 should be HEIGHT, measured in canonical character units.
1625 5. `:relative-height FACTOR' specifies that the height of the the
1626 stretch should be FACTOR times the height of the characters having
1629 Either none or exactly one of 4 or 5 must be present.
1631 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1632 of the stretch should be used for the ascent of the stretch.
1633 ASCENT must be in the range 0 <= ASCENT <= 100. */
1636 ((INTEGERP (X) || FLOATP (X)) \
1642 x_produce_stretch_glyph (it
)
1645 /* (space :width WIDTH :height HEIGHT. */
1647 extern Lisp_Object Qspace
;
1649 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
1650 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1651 extern Lisp_Object QCalign_to
;
1652 Lisp_Object prop
, plist
;
1653 double width
= 0, height
= 0, ascent
= 0;
1654 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1655 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1657 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1659 /* List should start with `space'. */
1660 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1661 plist
= XCDR (it
->object
);
1663 /* Compute the width of the stretch. */
1664 if (prop
= Fplist_get (plist
, QCwidth
),
1666 /* Absolute width `:width WIDTH' specified and valid. */
1667 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1668 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1671 /* Relative width `:relative-width FACTOR' specified and valid.
1672 Compute the width of the characters having the `glyph'
1675 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1678 if (it
->multibyte_p
)
1680 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1681 - IT_BYTEPOS (*it
));
1682 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1685 it2
.c
= *p
, it2
.len
= 1;
1687 it2
.glyph_row
= NULL
;
1688 it2
.what
= IT_CHARACTER
;
1689 x_produce_glyphs (&it2
);
1690 width
= NUMVAL (prop
) * it2
.pixel_width
;
1692 else if (prop
= Fplist_get (plist
, QCalign_to
),
1694 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1696 /* Nothing specified -> width defaults to canonical char width. */
1697 width
= CANON_X_UNIT (it
->f
);
1699 /* Compute height. */
1700 if (prop
= Fplist_get (plist
, QCheight
),
1702 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1703 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1705 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1707 height
= FONT_HEIGHT (font
);
1709 /* Compute percentage of height used for ascent. If
1710 `:ascent ASCENT' is present and valid, use that. Otherwise,
1711 derive the ascent from the font in use. */
1712 if (prop
= Fplist_get (plist
, QCascent
),
1713 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1714 ascent
= NUMVAL (prop
) / 100.0;
1716 ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1725 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1726 if (!STRINGP (object
))
1727 object
= it
->w
->buffer
;
1728 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1731 it
->pixel_width
= width
;
1732 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1733 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1736 if (face
->box
!= FACE_NO_BOX
)
1738 it
->ascent
+= face
->box_line_width
;
1739 it
->descent
+= face
->box_line_width
;
1741 if (it
->start_of_box_run_p
)
1742 it
->pixel_width
+= face
->box_line_width
;
1743 if (it
->end_of_box_run_p
)
1744 it
->pixel_width
+= face
->box_line_width
;
1747 take_vertical_position_into_account (it
);
1750 /* Return proper value to be used as baseline offset of font that has
1751 ASCENT and DESCENT to draw characters by the font at the vertical
1752 center of the line of frame F.
1754 Here, out task is to find the value of BOFF in the following figure;
1756 -------------------------+-----------+-
1757 -+-+---------+-+ | |
1759 | | | | F_ASCENT F_HEIGHT
1762 | | |-|-+------+-----------|------- baseline
1764 | |---------|-+-+ | |
1766 -+-+---------+-+ F_DESCENT |
1767 -------------------------+-----------+-
1769 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1770 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1771 DESCENT = FONT->descent
1772 HEIGHT = FONT_HEIGHT (FONT)
1773 F_DESCENT = (F->output_data.x->font->descent
1774 - F->output_data.x->baseline_offset)
1775 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1778 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1780 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
1781 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
1782 - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
1784 /* Produce glyphs/get display metrics for the display element IT is
1785 loaded with. See the description of struct display_iterator in
1786 dispextern.h for an overview of struct display_iterator. */
1789 x_produce_glyphs (it
)
1792 it
->glyph_not_available_p
= 0;
1794 if (it
->what
== IT_CHARACTER
)
1798 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1800 int font_not_found_p
;
1801 struct font_info
*font_info
;
1802 int boff
; /* baseline offset */
1803 /* We may change it->multibyte_p upon unibyte<->multibyte
1804 conversion. So, save the current value now and restore it
1807 Note: It seems that we don't have to record multibyte_p in
1808 struct glyph because the character code itself tells if or
1809 not the character is multibyte. Thus, in the future, we must
1810 consider eliminating the field `multibyte_p' in the struct
1813 int saved_multibyte_p
= it
->multibyte_p
;
1815 /* Maybe translate single-byte characters to multibyte, or the
1817 it
->char_to_display
= it
->c
;
1818 if (!ASCII_BYTE_P (it
->c
))
1820 if (unibyte_display_via_language_environment
1821 && SINGLE_BYTE_CHAR_P (it
->c
)
1823 || !NILP (Vnonascii_translation_table
)))
1825 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
1826 it
->multibyte_p
= 1;
1827 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1828 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1830 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
1831 && !it
->multibyte_p
)
1833 it
->char_to_display
= multibyte_char_to_unibyte (it
->c
, Qnil
);
1834 it
->multibyte_p
= 0;
1835 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1836 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1840 /* Get font to use. Encode IT->char_to_display. */
1841 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
1842 it
->face_id
, &char2b
,
1846 /* When no suitable font found, use the default font. */
1847 font_not_found_p
= font
== NULL
;
1848 if (font_not_found_p
)
1850 font
= FRAME_FONT (it
->f
);
1851 boff
= it
->f
->output_data
.x
->baseline_offset
;
1856 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
1857 boff
= font_info
->baseline_offset
;
1858 if (font_info
->vertical_centering
)
1859 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
1862 if (it
->char_to_display
>= ' '
1863 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
1865 /* Either unibyte or ASCII. */
1870 pcm
= x_per_char_metric (font
, &char2b
);
1871 it
->ascent
= font
->ascent
+ boff
;
1872 it
->descent
= font
->descent
- boff
;
1876 it
->phys_ascent
= pcm
->ascent
+ boff
;
1877 it
->phys_descent
= pcm
->descent
- boff
;
1878 it
->pixel_width
= pcm
->width
;
1882 it
->glyph_not_available_p
= 1;
1883 it
->phys_ascent
= font
->ascent
+ boff
;
1884 it
->phys_descent
= font
->descent
- boff
;
1885 it
->pixel_width
= FONT_WIDTH (font
);
1888 /* If this is a space inside a region of text with
1889 `space-width' property, change its width. */
1890 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
1892 it
->pixel_width
*= XFLOATINT (it
->space_width
);
1894 /* If face has a box, add the box thickness to the character
1895 height. If character has a box line to the left and/or
1896 right, add the box line width to the character's width. */
1897 if (face
->box
!= FACE_NO_BOX
)
1899 int thick
= face
->box_line_width
;
1901 it
->ascent
+= thick
;
1902 it
->descent
+= thick
;
1904 if (it
->start_of_box_run_p
)
1905 it
->pixel_width
+= thick
;
1906 if (it
->end_of_box_run_p
)
1907 it
->pixel_width
+= thick
;
1910 /* If face has an overline, add the height of the overline
1911 (1 pixel) and a 1 pixel margin to the character height. */
1912 if (face
->overline_p
)
1915 take_vertical_position_into_account (it
);
1917 /* If we have to actually produce glyphs, do it. */
1922 /* Translate a space with a `space-width' property
1923 into a stretch glyph. */
1924 double ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1925 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1926 it
->ascent
+ it
->descent
, ascent
);
1929 x_append_glyph (it
);
1931 /* If characters with lbearing or rbearing are displayed
1932 in this line, record that fact in a flag of the
1933 glyph row. This is used to optimize X output code. */
1934 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
1935 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1938 else if (it
->char_to_display
== '\n')
1940 /* A newline has no width but we need the height of the line. */
1941 it
->pixel_width
= 0;
1943 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1944 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1946 if (face
->box
!= FACE_NO_BOX
)
1948 int thick
= face
->box_line_width
;
1949 it
->ascent
+= thick
;
1950 it
->descent
+= thick
;
1953 else if (it
->char_to_display
== '\t')
1955 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
1956 int x
= it
->current_x
+ it
->continuation_lines_width
;
1957 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
1959 /* If the distance from the current position to the next tab
1960 stop is less than a canonical character width, use the
1961 tab stop after that. */
1962 if (next_tab_x
- x
< CANON_X_UNIT (it
->f
))
1963 next_tab_x
+= tab_width
;
1965 it
->pixel_width
= next_tab_x
- x
;
1967 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1968 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1972 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
1973 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1974 it
->ascent
+ it
->descent
, ascent
);
1979 /* A multi-byte character. Assume that the display width of the
1980 character is the width of the character multiplied by the
1981 width of the font. */
1983 /* If we found a font, this font should give us the right
1984 metrics. If we didn't find a font, use the frame's
1985 default font and calculate the width of the character
1986 from the charset width; this is what old redisplay code
1988 pcm
= x_per_char_metric (font
, &char2b
);
1989 if (font_not_found_p
|| !pcm
)
1991 int charset
= CHAR_CHARSET (it
->char_to_display
);
1993 it
->glyph_not_available_p
= 1;
1994 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
1995 * CHARSET_WIDTH (charset
));
1996 it
->phys_ascent
= font
->ascent
+ boff
;
1997 it
->phys_descent
= font
->descent
- boff
;
2001 it
->pixel_width
= pcm
->width
;
2002 it
->phys_ascent
= pcm
->ascent
+ boff
;
2003 it
->phys_descent
= pcm
->descent
- boff
;
2005 && (pcm
->lbearing
< 0
2006 || pcm
->rbearing
> pcm
->width
))
2007 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2010 it
->ascent
= font
->ascent
+ boff
;
2011 it
->descent
= font
->descent
- boff
;
2012 if (face
->box
!= FACE_NO_BOX
)
2014 int thick
= face
->box_line_width
;
2015 it
->ascent
+= thick
;
2016 it
->descent
+= thick
;
2018 if (it
->start_of_box_run_p
)
2019 it
->pixel_width
+= thick
;
2020 if (it
->end_of_box_run_p
)
2021 it
->pixel_width
+= thick
;
2024 /* If face has an overline, add the height of the overline
2025 (1 pixel) and a 1 pixel margin to the character height. */
2026 if (face
->overline_p
)
2029 take_vertical_position_into_account (it
);
2032 x_append_glyph (it
);
2034 it
->multibyte_p
= saved_multibyte_p
;
2036 else if (it
->what
== IT_COMPOSITION
)
2038 /* Note: A composition is represented as one glyph in the
2039 glyph matrix. There are no padding glyphs. */
2042 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2044 int font_not_found_p
;
2045 struct font_info
*font_info
;
2046 int boff
; /* baseline offset */
2047 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2049 /* Maybe translate single-byte characters to multibyte. */
2050 it
->char_to_display
= it
->c
;
2051 if (unibyte_display_via_language_environment
2052 && SINGLE_BYTE_CHAR_P (it
->c
)
2055 && !NILP (Vnonascii_translation_table
))))
2057 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2060 /* Get face and font to use. Encode IT->char_to_display. */
2061 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2062 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2063 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2064 it
->face_id
, &char2b
, it
->multibyte_p
);
2067 /* When no suitable font found, use the default font. */
2068 font_not_found_p
= font
== NULL
;
2069 if (font_not_found_p
)
2071 font
= FRAME_FONT (it
->f
);
2072 boff
= it
->f
->output_data
.x
->baseline_offset
;
2077 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2078 boff
= font_info
->baseline_offset
;
2079 if (font_info
->vertical_centering
)
2080 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2083 /* There are no padding glyphs, so there is only one glyph to
2084 produce for the composition. Important is that pixel_width,
2085 ascent and descent are the values of what is drawn by
2086 draw_glyphs (i.e. the values of the overall glyphs composed). */
2089 /* If we have not yet calculated pixel size data of glyphs of
2090 the composition for the current face font, calculate them
2091 now. Theoretically, we have to check all fonts for the
2092 glyphs, but that requires much time and memory space. So,
2093 here we check only the font of the first glyph. This leads
2094 to incorrect display very rarely, and C-l (recenter) can
2095 correct the display anyway. */
2096 if (cmp
->font
!= (void *) font
)
2098 /* Ascent and descent of the font of the first character of
2099 this composition (adjusted by baseline offset). Ascent
2100 and descent of overall glyphs should not be less than
2101 them respectively. */
2102 int font_ascent
= font
->ascent
+ boff
;
2103 int font_descent
= font
->descent
- boff
;
2104 /* Bounding box of the overall glyphs. */
2105 int leftmost
, rightmost
, lowest
, highest
;
2106 int i
, width
, ascent
, descent
;
2108 cmp
->font
= (void *) font
;
2110 /* Initialize the bounding box. */
2111 pcm
= x_per_char_metric (font
, &char2b
);
2115 ascent
= pcm
->ascent
;
2116 descent
= pcm
->descent
;
2120 width
= FONT_WIDTH (font
);
2121 ascent
= font
->ascent
;
2122 descent
= font
->descent
;
2126 lowest
= - descent
+ boff
;
2127 highest
= ascent
+ boff
;
2131 && font_info
->default_ascent
2132 && CHAR_TABLE_P (Vuse_default_ascent
)
2133 && !NILP (Faref (Vuse_default_ascent
,
2134 make_number (it
->char_to_display
))))
2135 highest
= font_info
->default_ascent
+ boff
;
2137 /* Draw the first glyph at the normal position. It may be
2138 shifted to right later if some other glyphs are drawn at
2140 cmp
->offsets
[0] = 0;
2141 cmp
->offsets
[1] = boff
;
2143 /* Set cmp->offsets for the remaining glyphs. */
2144 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2146 int left
, right
, btm
, top
;
2147 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2148 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2150 face
= FACE_FROM_ID (it
->f
, face_id
);
2151 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2156 font
= FRAME_FONT (it
->f
);
2157 boff
= it
->f
->output_data
.x
->baseline_offset
;
2163 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2164 boff
= font_info
->baseline_offset
;
2165 if (font_info
->vertical_centering
)
2166 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2169 pcm
= x_per_char_metric (font
, &char2b
);
2173 ascent
= pcm
->ascent
;
2174 descent
= pcm
->descent
;
2178 width
= FONT_WIDTH (font
);
2179 ascent
= font
->ascent
;
2180 descent
= font
->descent
;
2183 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2185 /* Relative composition with or without
2187 left
= (leftmost
+ rightmost
- width
) / 2;
2188 btm
= - descent
+ boff
;
2189 if (font_info
&& font_info
->relative_compose
2190 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2191 || NILP (Faref (Vignore_relative_composition
,
2192 make_number (ch
)))))
2195 if (- descent
>= font_info
->relative_compose
)
2196 /* One extra pixel between two glyphs. */
2198 else if (ascent
<= 0)
2199 /* One extra pixel between two glyphs. */
2200 btm
= lowest
- 1 - ascent
- descent
;
2205 /* A composition rule is specified by an integer
2206 value that encodes global and new reference
2207 points (GREF and NREF). GREF and NREF are
2208 specified by numbers as below:
2216 ---3---4---5--- baseline
2218 6---7---8 -- descent
2220 int rule
= COMPOSITION_RULE (cmp
, i
);
2221 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2223 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2224 grefx
= gref
% 3, nrefx
= nref
% 3;
2225 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2228 + grefx
* (rightmost
- leftmost
) / 2
2229 - nrefx
* width
/ 2);
2230 btm
= ((grefy
== 0 ? highest
2232 : grefy
== 2 ? lowest
2233 : (highest
+ lowest
) / 2)
2234 - (nrefy
== 0 ? ascent
+ descent
2235 : nrefy
== 1 ? descent
- boff
2237 : (ascent
+ descent
) / 2));
2240 cmp
->offsets
[i
* 2] = left
;
2241 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2243 /* Update the bounding box of the overall glyphs. */
2244 right
= left
+ width
;
2245 top
= btm
+ descent
+ ascent
;
2246 if (left
< leftmost
)
2248 if (right
> rightmost
)
2256 /* If there are glyphs whose x-offsets are negative,
2257 shift all glyphs to the right and make all x-offsets
2261 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2262 cmp
->offsets
[i
* 2] -= leftmost
;
2263 rightmost
-= leftmost
;
2266 cmp
->pixel_width
= rightmost
;
2267 cmp
->ascent
= highest
;
2268 cmp
->descent
= - lowest
;
2269 if (cmp
->ascent
< font_ascent
)
2270 cmp
->ascent
= font_ascent
;
2271 if (cmp
->descent
< font_descent
)
2272 cmp
->descent
= font_descent
;
2275 it
->pixel_width
= cmp
->pixel_width
;
2276 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2277 it
->descent
= it
->phys_descent
= cmp
->descent
;
2279 if (face
->box
!= FACE_NO_BOX
)
2281 int thick
= face
->box_line_width
;
2282 it
->ascent
+= thick
;
2283 it
->descent
+= thick
;
2285 if (it
->start_of_box_run_p
)
2286 it
->pixel_width
+= thick
;
2287 if (it
->end_of_box_run_p
)
2288 it
->pixel_width
+= thick
;
2291 /* If face has an overline, add the height of the overline
2292 (1 pixel) and a 1 pixel margin to the character height. */
2293 if (face
->overline_p
)
2296 take_vertical_position_into_account (it
);
2299 x_append_composite_glyph (it
);
2301 else if (it
->what
== IT_IMAGE
)
2302 x_produce_image_glyph (it
);
2303 else if (it
->what
== IT_STRETCH
)
2304 x_produce_stretch_glyph (it
);
2306 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2307 because this isn't true for images with `:ascent 100'. */
2308 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2309 if (it
->area
== TEXT_AREA
)
2310 it
->current_x
+= it
->pixel_width
;
2312 it
->descent
+= it
->extra_line_spacing
;
2314 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2315 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2316 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2317 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2321 /* Estimate the pixel height of the mode or top line on frame F.
2322 FACE_ID specifies what line's height to estimate. */
2325 x_estimate_mode_line_height (f
, face_id
)
2327 enum face_id face_id
;
2331 /* This function is called so early when Emacs starts that the face
2332 cache and mode line face are not yet initialized. */
2333 if (FRAME_FACE_CACHE (f
))
2335 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2337 height
= FONT_HEIGHT (face
->font
) + 2 * face
->box_line_width
;
2344 /***********************************************************************
2346 ***********************************************************************/
2348 /* A sequence of glyphs to be drawn in the same face.
2350 This data structure is not really completely X specific, so it
2351 could possibly, at least partially, be useful for other systems. It
2352 is currently not part of the external redisplay interface because
2353 it's not clear what other systems will need. */
2357 /* X-origin of the string. */
2360 /* Y-origin and y-position of the base line of this string. */
2363 /* The width of the string, not including a face extension. */
2366 /* The width of the string, including a face extension. */
2367 int background_width
;
2369 /* The height of this string. This is the height of the line this
2370 string is drawn in, and can be different from the height of the
2371 font the string is drawn in. */
2374 /* Number of pixels this string overwrites in front of its x-origin.
2375 This number is zero if the string has an lbearing >= 0; it is
2376 -lbearing, if the string has an lbearing < 0. */
2379 /* Number of pixels this string overwrites past its right-most
2380 nominal x-position, i.e. x + width. Zero if the string's
2381 rbearing is <= its nominal width, rbearing - width otherwise. */
2384 /* The frame on which the glyph string is drawn. */
2387 /* The window on which the glyph string is drawn. */
2390 /* X display and window for convenience. */
2394 /* The glyph row for which this string was built. It determines the
2395 y-origin and height of the string. */
2396 struct glyph_row
*row
;
2398 /* The area within row. */
2399 enum glyph_row_area area
;
2401 /* Characters to be drawn, and number of characters. */
2405 /* A face-override for drawing cursors, mouse face and similar. */
2406 enum draw_glyphs_face hl
;
2408 /* Face in which this string is to be drawn. */
2411 /* Font in which this string is to be drawn. */
2414 /* Font info for this string. */
2415 struct font_info
*font_info
;
2417 /* Non-null means this string describes (part of) a composition.
2418 All characters from char2b are drawn composed. */
2419 struct composition
*cmp
;
2421 /* Index of this glyph string's first character in the glyph
2422 definition of CMP. If this is zero, this glyph string describes
2423 the first character of a composition. */
2426 /* 1 means this glyph strings face has to be drawn to the right end
2427 of the window's drawing area. */
2428 unsigned extends_to_end_of_line_p
: 1;
2430 /* 1 means the background of this string has been drawn. */
2431 unsigned background_filled_p
: 1;
2433 /* 1 means glyph string must be drawn with 16-bit functions. */
2434 unsigned two_byte_p
: 1;
2436 /* 1 means that the original font determined for drawing this glyph
2437 string could not be loaded. The member `font' has been set to
2438 the frame's default font in this case. */
2439 unsigned font_not_found_p
: 1;
2441 /* 1 means that the face in which this glyph string is drawn has a
2443 unsigned stippled_p
: 1;
2445 /* 1 means only the foreground of this glyph string must be drawn,
2446 and we should use the physical height of the line this glyph
2447 string appears in as clip rect. */
2448 unsigned for_overlaps_p
: 1;
2450 /* The GC to use for drawing this glyph string. */
2453 /* A pointer to the first glyph in the string. This glyph
2454 corresponds to char2b[0]. Needed to draw rectangles if
2455 font_not_found_p is 1. */
2456 struct glyph
*first_glyph
;
2458 /* Image, if any. */
2461 struct glyph_string
*next
, *prev
;
2468 x_dump_glyph_string (s
)
2469 struct glyph_string
*s
;
2471 fprintf (stderr
, "glyph string\n");
2472 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2473 s
->x
, s
->y
, s
->width
, s
->height
);
2474 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2475 fprintf (stderr
, " hl = %d\n", s
->hl
);
2476 fprintf (stderr
, " left overhang = %d, right = %d\n",
2477 s
->left_overhang
, s
->right_overhang
);
2478 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2479 fprintf (stderr
, " extends to end of line = %d\n",
2480 s
->extends_to_end_of_line_p
);
2481 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2482 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2485 #endif /* GLYPH_DEBUG */
2489 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2490 struct glyph_string
**,
2491 struct glyph_string
*,
2492 struct glyph_string
*));
2493 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2494 struct glyph_string
**,
2495 struct glyph_string
*,
2496 struct glyph_string
*));
2497 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2498 struct glyph_string
**,
2499 struct glyph_string
*));
2500 static int x_left_overwritten
P_ ((struct glyph_string
*));
2501 static int x_left_overwriting
P_ ((struct glyph_string
*));
2502 static int x_right_overwritten
P_ ((struct glyph_string
*));
2503 static int x_right_overwriting
P_ ((struct glyph_string
*));
2504 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2506 static void x_init_glyph_string
P_ ((struct glyph_string
*,
2507 XChar2b
*, struct window
*,
2509 enum glyph_row_area
, int,
2510 enum draw_glyphs_face
));
2511 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2512 enum glyph_row_area
, int, int,
2513 enum draw_glyphs_face
, int *, int *, int));
2514 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2515 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2516 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2518 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2519 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2520 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2521 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2522 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2523 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2524 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2525 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2526 static void x_get_glyph_overhangs
P_ ((struct glyph
*, struct frame
*,
2528 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2529 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
2530 unsigned long *, double, int));
2531 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2532 double, int, unsigned long));
2533 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2534 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2535 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2536 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2537 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
2538 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2539 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2541 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2542 int, int, int, int, XRectangle
*));
2543 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2544 int, int, int, XRectangle
*));
2545 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2546 enum glyph_row_area
));
2547 static int x_fill_stretch_glyph_string
P_ ((struct glyph_string
*,
2549 enum glyph_row_area
, int, int));
2552 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2556 /* Append the list of glyph strings with head H and tail T to the list
2557 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2560 x_append_glyph_string_lists (head
, tail
, h
, t
)
2561 struct glyph_string
**head
, **tail
;
2562 struct glyph_string
*h
, *t
;
2576 /* Prepend the list of glyph strings with head H and tail T to the
2577 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2581 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2582 struct glyph_string
**head
, **tail
;
2583 struct glyph_string
*h
, *t
;
2597 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2598 Set *HEAD and *TAIL to the resulting list. */
2601 x_append_glyph_string (head
, tail
, s
)
2602 struct glyph_string
**head
, **tail
;
2603 struct glyph_string
*s
;
2605 s
->next
= s
->prev
= NULL
;
2606 x_append_glyph_string_lists (head
, tail
, s
, s
);
2610 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2615 struct glyph_string
*s
;
2617 if (s
->font
== FRAME_FONT (s
->f
)
2618 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2619 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2621 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
2624 /* Cursor on non-default face: must merge. */
2628 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
2629 xgcv
.foreground
= s
->face
->background
;
2631 /* If the glyph would be invisible, try a different foreground. */
2632 if (xgcv
.foreground
== xgcv
.background
)
2633 xgcv
.foreground
= s
->face
->foreground
;
2634 if (xgcv
.foreground
== xgcv
.background
)
2635 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
2636 if (xgcv
.foreground
== xgcv
.background
)
2637 xgcv
.foreground
= s
->face
->foreground
;
2639 /* Make sure the cursor is distinct from text in this face. */
2640 if (xgcv
.background
== s
->face
->background
2641 && xgcv
.foreground
== s
->face
->foreground
)
2643 xgcv
.background
= s
->face
->foreground
;
2644 xgcv
.foreground
= s
->face
->background
;
2647 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2648 xgcv
.font
= s
->font
->fid
;
2649 xgcv
.graphics_exposures
= False
;
2650 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2652 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2653 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2656 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2657 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2659 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2664 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2667 x_set_mouse_face_gc (s
)
2668 struct glyph_string
*s
;
2673 /* What face has to be used for the mouse face? */
2674 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2675 face
= FACE_FROM_ID (s
->f
, face_id
);
2676 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2677 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2679 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2680 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2681 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2683 /* If font in this face is same as S->font, use it. */
2684 if (s
->font
== s
->face
->font
)
2685 s
->gc
= s
->face
->gc
;
2688 /* Otherwise construct scratch_cursor_gc with values from FACE
2693 xgcv
.background
= s
->face
->background
;
2694 xgcv
.foreground
= s
->face
->foreground
;
2695 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2696 xgcv
.font
= s
->font
->fid
;
2697 xgcv
.graphics_exposures
= False
;
2698 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2700 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2701 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2704 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2705 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2707 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2710 xassert (s
->gc
!= 0);
2714 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2715 Faces to use in the mode line have already been computed when the
2716 matrix was built, so there isn't much to do, here. */
2719 x_set_mode_line_face_gc (s
)
2720 struct glyph_string
*s
;
2722 s
->gc
= s
->face
->gc
;
2726 /* Set S->gc of glyph string S for drawing that glyph string. Set
2727 S->stippled_p to a non-zero value if the face of S has a stipple
2731 x_set_glyph_string_gc (s
)
2732 struct glyph_string
*s
;
2734 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2736 if (s
->hl
== DRAW_NORMAL_TEXT
)
2738 s
->gc
= s
->face
->gc
;
2739 s
->stippled_p
= s
->face
->stipple
!= 0;
2741 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2743 x_set_mode_line_face_gc (s
);
2744 s
->stippled_p
= s
->face
->stipple
!= 0;
2746 else if (s
->hl
== DRAW_CURSOR
)
2748 x_set_cursor_gc (s
);
2751 else if (s
->hl
== DRAW_MOUSE_FACE
)
2753 x_set_mouse_face_gc (s
);
2754 s
->stippled_p
= s
->face
->stipple
!= 0;
2756 else if (s
->hl
== DRAW_IMAGE_RAISED
2757 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2759 s
->gc
= s
->face
->gc
;
2760 s
->stippled_p
= s
->face
->stipple
!= 0;
2764 s
->gc
= s
->face
->gc
;
2765 s
->stippled_p
= s
->face
->stipple
!= 0;
2768 /* GC must have been set. */
2769 xassert (s
->gc
!= 0);
2773 /* Return in *R the clipping rectangle for glyph string S. */
2776 x_get_glyph_string_clip_rect (s
, r
)
2777 struct glyph_string
*s
;
2780 if (s
->row
->full_width_p
)
2782 /* Draw full-width. X coordinates are relative to S->w->left. */
2783 int canon_x
= CANON_X_UNIT (s
->f
);
2785 r
->x
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
2786 r
->width
= XFASTINT (s
->w
->width
) * canon_x
;
2788 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
2790 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
2791 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
2795 r
->x
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
2797 /* Unless displaying a mode or menu bar line, which are always
2798 fully visible, clip to the visible part of the row. */
2799 if (s
->w
->pseudo_window_p
)
2800 r
->height
= s
->row
->visible_height
;
2802 r
->height
= s
->height
;
2806 /* This is a text line that may be partially visible. */
2807 r
->x
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
2808 r
->width
= window_box_width (s
->w
, s
->area
);
2809 r
->height
= s
->row
->visible_height
;
2812 /* Don't use S->y for clipping because it doesn't take partially
2813 visible lines into account. For example, it can be negative for
2814 partially visible lines at the top of a window. */
2815 if (!s
->row
->full_width_p
2816 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2817 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2819 r
->y
= max (0, s
->row
->y
);
2821 /* If drawing a tool-bar window, draw it over the internal border
2822 at the top of the window. */
2823 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
2824 r
->y
-= s
->f
->output_data
.x
->internal_border_width
;
2826 /* If S draws overlapping rows, it's sufficient to use the top and
2827 bottom of the window for clipping because this glyph string
2828 intentionally draws over other lines. */
2829 if (s
->for_overlaps_p
)
2831 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2832 r
->height
= window_text_bottom_y (s
->w
) - r
->y
;
2835 r
->y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->y
);
2839 /* Set clipping for output of glyph string S. S may be part of a mode
2840 line or menu if we don't have X toolkit support. */
2843 x_set_glyph_string_clipping (s
)
2844 struct glyph_string
*s
;
2847 x_get_glyph_string_clip_rect (s
, &r
);
2848 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
2852 /* Compute left and right overhang of glyph string S. If S is a glyph
2853 string for a composition, assume overhangs don't exist. */
2856 x_compute_glyph_string_overhangs (s
)
2857 struct glyph_string
*s
;
2860 && s
->first_glyph
->type
== CHAR_GLYPH
)
2863 int direction
, font_ascent
, font_descent
;
2864 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
2865 &font_ascent
, &font_descent
, &cs
);
2866 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2867 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2872 /* Compute overhangs and x-positions for glyph string S and its
2873 predecessors, or successors. X is the starting x-position for S.
2874 BACKWARD_P non-zero means process predecessors. */
2877 x_compute_overhangs_and_x (s
, x
, backward_p
)
2878 struct glyph_string
*s
;
2886 x_compute_glyph_string_overhangs (s
);
2896 x_compute_glyph_string_overhangs (s
);
2905 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2906 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2907 assumed to be zero. */
2910 x_get_glyph_overhangs (glyph
, f
, left
, right
)
2911 struct glyph
*glyph
;
2917 if (glyph
->type
== CHAR_GLYPH
)
2921 struct font_info
*font_info
;
2925 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
2927 font_info
= FONT_INFO_FROM_ID (f
, face
->font_info_id
);
2929 && (pcm
= x_per_char_metric (font
, &char2b
)))
2931 if (pcm
->rbearing
> pcm
->width
)
2932 *right
= pcm
->rbearing
- pcm
->width
;
2933 if (pcm
->lbearing
< 0)
2934 *left
= -pcm
->lbearing
;
2940 /* Return the index of the first glyph preceding glyph string S that
2941 is overwritten by S because of S's left overhang. Value is -1
2942 if no glyphs are overwritten. */
2945 x_left_overwritten (s
)
2946 struct glyph_string
*s
;
2950 if (s
->left_overhang
)
2953 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2954 int first
= s
->first_glyph
- glyphs
;
2956 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
2957 x
-= glyphs
[i
].pixel_width
;
2968 /* Return the index of the first glyph preceding glyph string S that
2969 is overwriting S because of its right overhang. Value is -1 if no
2970 glyph in front of S overwrites S. */
2973 x_left_overwriting (s
)
2974 struct glyph_string
*s
;
2977 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2978 int first
= s
->first_glyph
- glyphs
;
2982 for (i
= first
- 1; i
>= 0; --i
)
2985 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
2988 x
-= glyphs
[i
].pixel_width
;
2995 /* Return the index of the last glyph following glyph string S that is
2996 not overwritten by S because of S's right overhang. Value is -1 if
2997 no such glyph is found. */
3000 x_right_overwritten (s
)
3001 struct glyph_string
*s
;
3005 if (s
->right_overhang
)
3008 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3009 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3010 int end
= s
->row
->used
[s
->area
];
3012 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3013 x
+= glyphs
[i
].pixel_width
;
3022 /* Return the index of the last glyph following glyph string S that
3023 overwrites S because of its left overhang. Value is negative
3024 if no such glyph is found. */
3027 x_right_overwriting (s
)
3028 struct glyph_string
*s
;
3031 int end
= s
->row
->used
[s
->area
];
3032 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3033 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3037 for (i
= first
; i
< end
; ++i
)
3040 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3043 x
+= glyphs
[i
].pixel_width
;
3050 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3053 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3054 struct glyph_string
*s
;
3058 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
3059 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3060 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3061 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3065 /* Draw the background of glyph_string S. If S->background_filled_p
3066 is non-zero don't draw it. FORCE_P non-zero means draw the
3067 background even if it wouldn't be drawn normally. This is used
3068 when a string preceding S draws into the background of S, or S
3069 contains the first component of a composition. */
3072 x_draw_glyph_string_background (s
, force_p
)
3073 struct glyph_string
*s
;
3076 /* Nothing to do if background has already been drawn or if it
3077 shouldn't be drawn in the first place. */
3078 if (!s
->background_filled_p
)
3082 /* Fill background with a stipple pattern. */
3083 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3084 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3085 s
->y
+ s
->face
->box_line_width
,
3086 s
->background_width
,
3087 s
->height
- 2 * s
->face
->box_line_width
);
3088 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3089 s
->background_filled_p
= 1;
3091 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * s
->face
->box_line_width
3092 || s
->font_not_found_p
3093 || s
->extends_to_end_of_line_p
3096 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ s
->face
->box_line_width
,
3097 s
->background_width
,
3098 s
->height
- 2 * s
->face
->box_line_width
);
3099 s
->background_filled_p
= 1;
3105 /* Draw the foreground of glyph string S. */
3108 x_draw_glyph_string_foreground (s
)
3109 struct glyph_string
*s
;
3113 /* If first glyph of S has a left box line, start drawing the text
3114 of S to the right of that box line. */
3115 if (s
->face
->box
!= FACE_NO_BOX
3116 && s
->first_glyph
->left_box_line_p
)
3117 x
= s
->x
+ s
->face
->box_line_width
;
3121 /* Draw characters of S as rectangles if S's font could not be
3123 if (s
->font_not_found_p
)
3125 for (i
= 0; i
< s
->nchars
; ++i
)
3127 struct glyph
*g
= s
->first_glyph
+ i
;
3128 XDrawRectangle (s
->display
, s
->window
,
3129 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3131 x
+= g
->pixel_width
;
3136 char *char1b
= (char *) s
->char2b
;
3137 int boff
= s
->font_info
->baseline_offset
;
3139 if (s
->font_info
->vertical_centering
)
3140 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3142 /* If we can use 8-bit functions, condense S->char2b. */
3144 for (i
= 0; i
< s
->nchars
; ++i
)
3145 char1b
[i
] = s
->char2b
[i
].byte2
;
3147 /* Draw text with XDrawString if background has already been
3148 filled. Otherwise, use XDrawImageString. (Note that
3149 XDrawImageString is usually faster than XDrawString.) Always
3150 use XDrawImageString when drawing the cursor so that there is
3151 no chance that characters under a box cursor are invisible. */
3152 if (s
->for_overlaps_p
3153 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3155 /* Draw characters with 16-bit or 8-bit functions. */
3157 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
3158 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3160 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
3161 s
->ybase
- boff
, char1b
, s
->nchars
);
3166 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
3167 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3169 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
3170 s
->ybase
- boff
, char1b
, s
->nchars
);
3175 /* Draw the foreground of composite glyph string S. */
3178 x_draw_composite_glyph_string_foreground (s
)
3179 struct glyph_string
*s
;
3183 /* If first glyph of S has a left box line, start drawing the text
3184 of S to the right of that box line. */
3185 if (s
->face
->box
!= FACE_NO_BOX
3186 && s
->first_glyph
->left_box_line_p
)
3187 x
= s
->x
+ s
->face
->box_line_width
;
3191 /* S is a glyph string for a composition. S->gidx is the index of
3192 the first character drawn for glyphs of this composition.
3193 S->gidx == 0 means we are drawing the very first character of
3194 this composition. */
3196 /* Draw a rectangle for the composition if the font for the very
3197 first character of the composition could not be loaded. */
3198 if (s
->font_not_found_p
)
3201 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
3202 s
->width
- 1, s
->height
- 1);
3206 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3207 XDrawString16 (s
->display
, s
->window
, s
->gc
,
3208 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3209 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3215 #ifdef USE_X_TOOLKIT
3217 static struct frame
*x_frame_of_widget
P_ ((Widget
));
3220 /* Return the frame on which widget WIDGET is used.. Abort if frame
3221 cannot be determined. */
3223 static struct frame
*
3224 x_frame_of_widget (widget
)
3227 struct x_display_info
*dpyinfo
;
3231 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3233 /* Find the top-level shell of the widget. Note that this function
3234 can be called when the widget is not yet realized, so XtWindow
3235 (widget) == 0. That's the reason we can't simply use
3236 x_any_window_to_frame. */
3237 while (!XtIsTopLevelShell (widget
))
3238 widget
= XtParent (widget
);
3240 /* Look for a frame with that top-level widget. Allocate the color
3241 on that frame to get the right gamma correction value. */
3242 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3243 if (GC_FRAMEP (XCAR (tail
))
3244 && (f
= XFRAME (XCAR (tail
)),
3245 (f
->output_data
.nothing
!= 1
3246 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3247 && f
->output_data
.x
->widget
== widget
)
3254 /* Allocate the color COLOR->pixel on the screen and display of
3255 widget WIDGET in colormap CMAP. If an exact match cannot be
3256 allocated, try the nearest color available. Value is non-zero
3257 if successful. This is called from lwlib. */
3260 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3265 struct frame
*f
= x_frame_of_widget (widget
);
3266 return x_alloc_nearest_color (f
, cmap
, color
);
3270 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3271 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3272 If this produces the same color as PIXEL, try a color where all RGB
3273 values have DELTA added. Return the allocated color in *PIXEL.
3274 DISPLAY is the X display, CMAP is the colormap to operate on.
3275 Value is non-zero if successful. */
3278 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
3282 unsigned long *pixel
;
3286 struct frame
*f
= x_frame_of_widget (widget
);
3287 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
3291 #endif /* USE_X_TOOLKIT */
3294 /* Value is an array of XColor structures for the contents of the
3295 color map of frame F. Set *NCELLS to the size of the array.
3296 Note that this probably shouldn't be called for large color maps,
3297 say a 24-bit TrueColor map. */
3299 static const XColor
*
3300 x_color_cells (f
, ncells
)
3304 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3306 if (dpyinfo
->color_cells
== NULL
)
3308 Display
*display
= FRAME_X_DISPLAY (f
);
3309 Screen
*screen
= FRAME_X_SCREEN (f
);
3312 dpyinfo
->ncolor_cells
3313 = XDisplayCells (display
, XScreenNumberOfScreen (screen
));
3314 dpyinfo
->color_cells
3315 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
3316 * sizeof *dpyinfo
->color_cells
);
3318 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
3319 dpyinfo
->color_cells
[i
].pixel
= i
;
3321 XQueryColors (display
, FRAME_X_COLORMAP (f
),
3322 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
3325 *ncells
= dpyinfo
->ncolor_cells
;
3326 return dpyinfo
->color_cells
;
3330 /* On frame F, translate pixel colors to RGB values for the NCOLORS
3331 colors in COLORS. Use cached information, if available. */
3334 x_query_colors (f
, colors
, ncolors
)
3339 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3341 if (dpyinfo
->color_cells
)
3344 for (i
= 0; i
< ncolors
; ++i
)
3346 unsigned long pixel
= colors
[i
].pixel
;
3347 xassert (pixel
< dpyinfo
->ncolor_cells
);
3348 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
3349 colors
[i
] = dpyinfo
->color_cells
[pixel
];
3353 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
3357 /* On frame F, translate pixel color to RGB values for the color in
3358 COLOR. Use cached information, if available. */
3361 x_query_color (f
, color
)
3365 x_query_colors (f
, color
, 1);
3369 /* Allocate the color COLOR->pixel on SCREEN of DISPLAY, colormap
3370 CMAP. If an exact match can't be allocated, try the nearest color
3371 available. Value is non-zero if successful. Set *COLOR to the
3375 x_alloc_nearest_color (f
, cmap
, color
)
3380 Display
*display
= FRAME_X_DISPLAY (f
);
3381 Screen
*screen
= FRAME_X_SCREEN (f
);
3384 gamma_correct (f
, color
);
3385 rc
= XAllocColor (display
, cmap
, color
);
3388 /* If we got to this point, the colormap is full, so we're going
3389 to try to get the next closest color. The algorithm used is
3390 a least-squares matching, which is what X uses for closest
3391 color matching with StaticColor visuals. */
3393 unsigned long nearest_delta
= ~0;
3395 const XColor
*cells
= x_color_cells (f
, &ncells
);
3397 for (nearest
= i
= 0; i
< ncells
; ++i
)
3399 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3400 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3401 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3402 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3404 if (delta
< nearest_delta
)
3407 nearest_delta
= delta
;
3411 color
->red
= cells
[nearest
].red
;
3412 color
->green
= cells
[nearest
].green
;
3413 color
->blue
= cells
[nearest
].blue
;
3414 rc
= XAllocColor (display
, cmap
, color
);
3418 /* If allocation succeeded, and the allocated pixel color is not
3419 equal to a cached pixel color recorded earlier, there was a
3420 change in the colormap, so clear the color cache. */
3421 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3422 XColor
*cached_color
;
3424 if (dpyinfo
->color_cells
3425 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
3426 (cached_color
->red
!= color
->red
3427 || cached_color
->blue
!= color
->blue
3428 || cached_color
->green
!= color
->green
)))
3430 xfree (dpyinfo
->color_cells
);
3431 dpyinfo
->color_cells
= NULL
;
3432 dpyinfo
->ncolor_cells
= 0;
3436 #ifdef DEBUG_X_COLORS
3438 register_color (color
->pixel
);
3439 #endif /* DEBUG_X_COLORS */
3445 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3446 It's necessary to do this instead of just using PIXEL directly to
3447 get color reference counts right. */
3450 x_copy_color (f
, pixel
)
3452 unsigned long pixel
;
3456 color
.pixel
= pixel
;
3458 x_query_color (f
, &color
);
3459 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3461 #ifdef DEBUG_X_COLORS
3462 register_color (pixel
);
3468 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3469 It's necessary to do this instead of just using PIXEL directly to
3470 get color reference counts right. */
3473 x_copy_dpy_color (dpy
, cmap
, pixel
)
3476 unsigned long pixel
;
3480 color
.pixel
= pixel
;
3482 XQueryColor (dpy
, cmap
, &color
);
3483 XAllocColor (dpy
, cmap
, &color
);
3485 #ifdef DEBUG_X_COLORS
3486 register_color (pixel
);
3492 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3493 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3494 If this produces the same color as PIXEL, try a color where all RGB
3495 values have DELTA added. Return the allocated color in *PIXEL.
3496 DISPLAY is the X display, CMAP is the colormap to operate on.
3497 Value is non-zero if successful. */
3500 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
3504 unsigned long *pixel
;
3511 /* Get RGB color values. */
3512 color
.pixel
= *pixel
;
3513 x_query_color (f
, &color
);
3515 /* Change RGB values by specified FACTOR. Avoid overflow! */
3516 xassert (factor
>= 0);
3517 new.red
= min (0xffff, factor
* color
.red
);
3518 new.green
= min (0xffff, factor
* color
.green
);
3519 new.blue
= min (0xffff, factor
* color
.blue
);
3521 /* Try to allocate the color. */
3522 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3525 if (new.pixel
== *pixel
)
3527 /* If we end up with the same color as before, try adding
3528 delta to the RGB values. */
3529 x_free_colors (f
, &new.pixel
, 1);
3531 new.red
= min (0xffff, delta
+ color
.red
);
3532 new.green
= min (0xffff, delta
+ color
.green
);
3533 new.blue
= min (0xffff, delta
+ color
.blue
);
3534 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3545 /* Set up the foreground color for drawing relief lines of glyph
3546 string S. RELIEF is a pointer to a struct relief containing the GC
3547 with which lines will be drawn. Use a color that is FACTOR or
3548 DELTA lighter or darker than the relief's background which is found
3549 in S->f->output_data.x->relief_background. If such a color cannot
3550 be allocated, use DEFAULT_PIXEL, instead. */
3553 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3555 struct relief
*relief
;
3558 unsigned long default_pixel
;
3561 struct x_output
*di
= f
->output_data
.x
;
3562 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
3563 unsigned long pixel
;
3564 unsigned long background
= di
->relief_background
;
3565 Colormap cmap
= FRAME_X_COLORMAP (f
);
3566 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3567 Display
*dpy
= FRAME_X_DISPLAY (f
);
3569 xgcv
.graphics_exposures
= False
;
3570 xgcv
.line_width
= 1;
3572 /* Free previously allocated color. The color cell will be reused
3573 when it has been freed as many times as it was allocated, so this
3574 doesn't affect faces using the same colors. */
3576 && relief
->allocated_p
)
3578 x_free_colors (f
, &relief
->pixel
, 1);
3579 relief
->allocated_p
= 0;
3582 /* Allocate new color. */
3583 xgcv
.foreground
= default_pixel
;
3585 if (dpyinfo
->n_planes
!= 1
3586 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
3588 relief
->allocated_p
= 1;
3589 xgcv
.foreground
= relief
->pixel
= pixel
;
3592 if (relief
->gc
== 0)
3594 xgcv
.stipple
= dpyinfo
->gray
;
3596 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
3599 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
3603 /* Set up colors for the relief lines around glyph string S. */
3606 x_setup_relief_colors (s
)
3607 struct glyph_string
*s
;
3609 struct x_output
*di
= s
->f
->output_data
.x
;
3610 unsigned long color
;
3612 if (s
->face
->use_box_color_for_shadows_p
)
3613 color
= s
->face
->box_color
;
3618 /* Get the background color of the face. */
3619 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3620 color
= xgcv
.background
;
3623 if (di
->white_relief
.gc
== 0
3624 || color
!= di
->relief_background
)
3626 di
->relief_background
= color
;
3627 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3628 WHITE_PIX_DEFAULT (s
->f
));
3629 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3630 BLACK_PIX_DEFAULT (s
->f
));
3635 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3636 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3637 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3638 relief. LEFT_P non-zero means draw a relief on the left side of
3639 the rectangle. RIGHT_P non-zero means draw a relief on the right
3640 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3644 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3645 raised_p
, left_p
, right_p
, clip_rect
)
3647 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3648 XRectangle
*clip_rect
;
3654 gc
= f
->output_data
.x
->white_relief
.gc
;
3656 gc
= f
->output_data
.x
->black_relief
.gc
;
3657 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3660 for (i
= 0; i
< width
; ++i
)
3661 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3662 left_x
+ i
* left_p
, top_y
+ i
,
3663 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3667 for (i
= 0; i
< width
; ++i
)
3668 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3669 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
);
3671 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3673 gc
= f
->output_data
.x
->black_relief
.gc
;
3675 gc
= f
->output_data
.x
->white_relief
.gc
;
3676 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3679 for (i
= 0; i
< width
; ++i
)
3680 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3681 left_x
+ i
* left_p
, bottom_y
- i
,
3682 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3686 for (i
= 0; i
< width
; ++i
)
3687 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3688 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3690 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3694 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3695 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3696 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3697 left side of the rectangle. RIGHT_P non-zero means draw a line
3698 on the right side of the rectangle. CLIP_RECT is the clipping
3699 rectangle to use when drawing. */
3702 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3703 left_p
, right_p
, clip_rect
)
3704 struct glyph_string
*s
;
3705 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
;
3706 XRectangle
*clip_rect
;
3710 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3711 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3712 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
3715 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3716 left_x
, top_y
, right_x
- left_x
+ 1, width
);
3720 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3721 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
3724 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3725 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
3729 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3730 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
3732 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3733 XSetClipMask (s
->display
, s
->gc
, None
);
3737 /* Draw a box around glyph string S. */
3740 x_draw_glyph_string_box (s
)
3741 struct glyph_string
*s
;
3743 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3744 int left_p
, right_p
;
3745 struct glyph
*last_glyph
;
3746 XRectangle clip_rect
;
3748 last_x
= window_box_right (s
->w
, s
->area
);
3749 if (s
->row
->full_width_p
3750 && !s
->w
->pseudo_window_p
)
3752 last_x
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s
->f
);
3753 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
3754 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
3757 /* The glyph that may have a right box line. */
3758 last_glyph
= (s
->cmp
|| s
->img
3760 : s
->first_glyph
+ s
->nchars
- 1);
3762 width
= s
->face
->box_line_width
;
3763 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3765 right_x
= ((s
->row
->full_width_p
3767 : min (last_x
, s
->x
+ s
->background_width
) - 1));
3769 bottom_y
= top_y
+ s
->height
- 1;
3771 left_p
= (s
->first_glyph
->left_box_line_p
3772 || (s
->hl
== DRAW_MOUSE_FACE
3774 || s
->prev
->hl
!= s
->hl
)));
3775 right_p
= (last_glyph
->right_box_line_p
3776 || (s
->hl
== DRAW_MOUSE_FACE
3778 || s
->next
->hl
!= s
->hl
)));
3780 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3782 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3783 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3784 left_p
, right_p
, &clip_rect
);
3787 x_setup_relief_colors (s
);
3788 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3789 width
, raised_p
, left_p
, right_p
, &clip_rect
);
3794 /* Draw foreground of image glyph string S. */
3797 x_draw_image_foreground (s
)
3798 struct glyph_string
*s
;
3801 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3803 /* If first glyph of S has a left box line, start drawing it to the
3804 right of that line. */
3805 if (s
->face
->box
!= FACE_NO_BOX
3806 && s
->first_glyph
->left_box_line_p
)
3807 x
= s
->x
+ s
->face
->box_line_width
;
3811 /* If there is a margin around the image, adjust x- and y-position
3815 x
+= s
->img
->margin
;
3816 y
+= s
->img
->margin
;
3823 /* We can't set both a clip mask and use XSetClipRectangles
3824 because the latter also sets a clip mask. We also can't
3825 trust on the shape extension to be available
3826 (XShapeCombineRegion). So, compute the rectangle to draw
3828 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3831 XRectangle clip_rect
, image_rect
, r
;
3833 xgcv
.clip_mask
= s
->img
->mask
;
3834 xgcv
.clip_x_origin
= x
;
3835 xgcv
.clip_y_origin
= y
;
3836 xgcv
.function
= GXcopy
;
3837 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3839 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3842 image_rect
.width
= s
->img
->width
;
3843 image_rect
.height
= s
->img
->height
;
3844 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
3845 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3846 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
3850 unsigned long mask
= GCClipXOrigin
| GCClipYOrigin
| GCFunction
;
3852 XRectangle clip_rect
, image_rect
, r
;
3854 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3857 image_rect
.width
= s
->img
->width
;
3858 image_rect
.height
= s
->img
->height
;
3859 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
3860 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3861 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
3863 /* When the image has a mask, we can expect that at
3864 least part of a mouse highlight or a block cursor will
3865 be visible. If the image doesn't have a mask, make
3866 a block cursor visible by drawing a rectangle around
3867 the image. I believe it's looking better if we do
3868 nothing here for mouse-face. */
3869 if (s
->hl
== DRAW_CURSOR
)
3870 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
3871 s
->img
->width
- 1, s
->img
->height
- 1);
3875 /* Draw a rectangle if image could not be loaded. */
3876 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
3877 s
->img
->width
- 1, s
->img
->height
- 1);
3881 /* Draw a relief around the image glyph string S. */
3884 x_draw_image_relief (s
)
3885 struct glyph_string
*s
;
3887 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3890 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3892 /* If first glyph of S has a left box line, start drawing it to the
3893 right of that line. */
3894 if (s
->face
->box
!= FACE_NO_BOX
3895 && s
->first_glyph
->left_box_line_p
)
3896 x
= s
->x
+ s
->face
->box_line_width
;
3900 /* If there is a margin around the image, adjust x- and y-position
3904 x
+= s
->img
->margin
;
3905 y
+= s
->img
->margin
;
3908 if (s
->hl
== DRAW_IMAGE_SUNKEN
3909 || s
->hl
== DRAW_IMAGE_RAISED
)
3911 thick
= tool_bar_button_relief
> 0 ? tool_bar_button_relief
: 3;
3912 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3916 thick
= abs (s
->img
->relief
);
3917 raised_p
= s
->img
->relief
> 0;
3922 x1
= x
+ s
->img
->width
+ thick
- 1;
3923 y1
= y
+ s
->img
->height
+ thick
- 1;
3925 x_setup_relief_colors (s
);
3926 x_get_glyph_string_clip_rect (s
, &r
);
3927 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
3931 /* Draw the foreground of image glyph string S to PIXMAP. */
3934 x_draw_image_foreground_1 (s
, pixmap
)
3935 struct glyph_string
*s
;
3939 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
3941 /* If first glyph of S has a left box line, start drawing it to the
3942 right of that line. */
3943 if (s
->face
->box
!= FACE_NO_BOX
3944 && s
->first_glyph
->left_box_line_p
)
3945 x
= s
->face
->box_line_width
;
3949 /* If there is a margin around the image, adjust x- and y-position
3953 x
+= s
->img
->margin
;
3954 y
+= s
->img
->margin
;
3961 /* We can't set both a clip mask and use XSetClipRectangles
3962 because the latter also sets a clip mask. We also can't
3963 trust on the shape extension to be available
3964 (XShapeCombineRegion). So, compute the rectangle to draw
3966 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3970 xgcv
.clip_mask
= s
->img
->mask
;
3971 xgcv
.clip_x_origin
= x
;
3972 xgcv
.clip_y_origin
= y
;
3973 xgcv
.function
= GXcopy
;
3974 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3976 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3977 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3978 XSetClipMask (s
->display
, s
->gc
, None
);
3982 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3983 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3985 /* When the image has a mask, we can expect that at
3986 least part of a mouse highlight or a block cursor will
3987 be visible. If the image doesn't have a mask, make
3988 a block cursor visible by drawing a rectangle around
3989 the image. I believe it's looking better if we do
3990 nothing here for mouse-face. */
3991 if (s
->hl
== DRAW_CURSOR
)
3992 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
3993 s
->img
->width
- 1, s
->img
->height
- 1);
3997 /* Draw a rectangle if image could not be loaded. */
3998 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
3999 s
->img
->width
- 1, s
->img
->height
- 1);
4003 /* Draw part of the background of glyph string S. X, Y, W, and H
4004 give the rectangle to draw. */
4007 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4008 struct glyph_string
*s
;
4013 /* Fill background with a stipple pattern. */
4014 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4015 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4016 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4019 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4023 /* Draw image glyph string S.
4026 s->x +-------------------------
4029 | +-------------------------
4032 | | +-------------------
4038 x_draw_image_glyph_string (s
)
4039 struct glyph_string
*s
;
4042 int box_line_width
= s
->face
->box_line_width
;
4043 int margin
= s
->img
->margin
;
4045 Pixmap pixmap
= None
;
4047 height
= s
->height
- 2 * box_line_width
;
4049 /* Fill background with face under the image. Do it only if row is
4050 taller than image or if image has a clip mask to reduce
4052 s
->stippled_p
= s
->face
->stipple
!= 0;
4053 if (height
> s
->img
->height
4056 || s
->img
->pixmap
== 0
4057 || s
->width
!= s
->background_width
)
4059 if (box_line_width
&& s
->first_glyph
->left_box_line_p
)
4060 x
= s
->x
+ box_line_width
;
4064 y
= s
->y
+ box_line_width
;
4068 /* Create a pixmap as large as the glyph string. Fill it
4069 with the background color. Copy the image to it, using
4070 its mask. Copy the temporary pixmap to the display. */
4071 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4072 int depth
= DefaultDepthOfScreen (screen
);
4074 /* Create a pixmap as large as the glyph string. */
4075 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4076 s
->background_width
,
4079 /* Don't clip in the following because we're working on the
4081 XSetClipMask (s
->display
, s
->gc
, None
);
4083 /* Fill the pixmap with the background color/stipple. */
4086 /* Fill background with a stipple pattern. */
4087 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4088 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4089 0, 0, s
->background_width
, s
->height
);
4090 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4095 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4097 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4098 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4099 0, 0, s
->background_width
, s
->height
);
4100 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4104 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4106 s
->background_filled_p
= 1;
4109 /* Draw the foreground. */
4112 x_draw_image_foreground_1 (s
, pixmap
);
4113 x_set_glyph_string_clipping (s
);
4114 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
4115 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
4116 XFreePixmap (s
->display
, pixmap
);
4119 x_draw_image_foreground (s
);
4121 /* If we must draw a relief around the image, do it. */
4123 || s
->hl
== DRAW_IMAGE_RAISED
4124 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4125 x_draw_image_relief (s
);
4129 /* Draw stretch glyph string S. */
4132 x_draw_stretch_glyph_string (s
)
4133 struct glyph_string
*s
;
4135 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4136 s
->stippled_p
= s
->face
->stipple
!= 0;
4138 if (s
->hl
== DRAW_CURSOR
4139 && !x_stretch_cursor_p
)
4141 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4142 as wide as the stretch glyph. */
4143 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4146 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4148 /* Clear rest using the GC of the original non-cursor face. */
4149 if (width
< s
->background_width
)
4151 GC gc
= s
->face
->gc
;
4152 int x
= s
->x
+ width
, y
= s
->y
;
4153 int w
= s
->background_width
- width
, h
= s
->height
;
4156 x_get_glyph_string_clip_rect (s
, &r
);
4157 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
4159 if (s
->face
->stipple
)
4161 /* Fill background with a stipple pattern. */
4162 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4163 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4164 XSetFillStyle (s
->display
, gc
, FillSolid
);
4169 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
4170 XSetForeground (s
->display
, gc
, xgcv
.background
);
4171 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4172 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
4177 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4180 s
->background_filled_p
= 1;
4184 /* Draw glyph string S. */
4187 x_draw_glyph_string (s
)
4188 struct glyph_string
*s
;
4190 /* If S draws into the background of its successor, draw the
4191 background of the successor first so that S can draw into it.
4192 This makes S->next use XDrawString instead of XDrawImageString. */
4193 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4195 xassert (s
->next
->img
== NULL
);
4196 x_set_glyph_string_gc (s
->next
);
4197 x_set_glyph_string_clipping (s
->next
);
4198 x_draw_glyph_string_background (s
->next
, 1);
4201 /* Set up S->gc, set clipping and draw S. */
4202 x_set_glyph_string_gc (s
);
4203 x_set_glyph_string_clipping (s
);
4205 switch (s
->first_glyph
->type
)
4208 x_draw_image_glyph_string (s
);
4212 x_draw_stretch_glyph_string (s
);
4216 if (s
->for_overlaps_p
)
4217 s
->background_filled_p
= 1;
4219 x_draw_glyph_string_background (s
, 0);
4220 x_draw_glyph_string_foreground (s
);
4223 case COMPOSITE_GLYPH
:
4224 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4225 s
->background_filled_p
= 1;
4227 x_draw_glyph_string_background (s
, 1);
4228 x_draw_composite_glyph_string_foreground (s
);
4235 if (!s
->for_overlaps_p
)
4237 /* Draw underline. */
4238 if (s
->face
->underline_p
)
4240 unsigned long tem
, h
;
4243 /* Get the underline thickness. Default is 1 pixel. */
4244 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
4247 /* Get the underline position. This is the recommended
4248 vertical offset in pixels from the baseline to the top of
4249 the underline. This is a signed value according to the
4250 specs, and its default is
4252 ROUND ((maximum descent) / 2), with
4253 ROUND(x) = floor (x + 0.5) */
4255 if (XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
4256 y
= s
->ybase
+ (long) tem
;
4257 else if (s
->face
->font
)
4258 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
4262 if (s
->face
->underline_defaulted_p
)
4263 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4264 s
->x
, y
, s
->width
, h
);
4268 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4269 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
4270 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4271 s
->x
, y
, s
->width
, h
);
4272 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4276 /* Draw overline. */
4277 if (s
->face
->overline_p
)
4279 unsigned long dy
= 0, h
= 1;
4281 if (s
->face
->overline_color_defaulted_p
)
4282 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4287 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4288 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4289 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4291 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4295 /* Draw strike-through. */
4296 if (s
->face
->strike_through_p
)
4298 unsigned long h
= 1;
4299 unsigned long dy
= (s
->height
- h
) / 2;
4301 if (s
->face
->strike_through_color_defaulted_p
)
4302 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4307 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4308 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4309 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4311 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4316 if (s
->face
->box
!= FACE_NO_BOX
)
4317 x_draw_glyph_string_box (s
);
4320 /* Reset clipping. */
4321 XSetClipMask (s
->display
, s
->gc
, None
);
4325 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4326 struct face
**, int));
4329 /* Fill glyph string S with composition components specified by S->cmp.
4331 FACES is an array of faces for all components of this composition.
4332 S->gidx is the index of the first component for S.
4333 OVERLAPS_P non-zero means S should draw the foreground only, and
4334 use its physical height for clipping.
4336 Value is the index of a component not in S. */
4339 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4340 struct glyph_string
*s
;
4341 struct face
**faces
;
4348 s
->for_overlaps_p
= overlaps_p
;
4350 s
->face
= faces
[s
->gidx
];
4351 s
->font
= s
->face
->font
;
4352 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4354 /* For all glyphs of this composition, starting at the offset
4355 S->gidx, until we reach the end of the definition or encounter a
4356 glyph that requires the different face, add it to S. */
4358 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4361 /* All glyph strings for the same composition has the same width,
4362 i.e. the width set for the first component of the composition. */
4364 s
->width
= s
->first_glyph
->pixel_width
;
4366 /* If the specified font could not be loaded, use the frame's
4367 default font, but record the fact that we couldn't load it in
4368 the glyph string so that we can draw rectangles for the
4369 characters of the glyph string. */
4370 if (s
->font
== NULL
)
4372 s
->font_not_found_p
= 1;
4373 s
->font
= FRAME_FONT (s
->f
);
4376 /* Adjust base line for subscript/superscript text. */
4377 s
->ybase
+= s
->first_glyph
->voffset
;
4379 xassert (s
->face
&& s
->face
->gc
);
4381 /* This glyph string must always be drawn with 16-bit functions. */
4384 return s
->gidx
+ s
->nchars
;
4388 /* Fill glyph string S from a sequence of character glyphs.
4390 FACE_ID is the face id of the string. START is the index of the
4391 first glyph to consider, END is the index of the last + 1.
4392 OVERLAPS_P non-zero means S should draw the foreground only, and
4393 use its physical height for clipping.
4395 Value is the index of the first glyph not in S. */
4398 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4399 struct glyph_string
*s
;
4401 int start
, end
, overlaps_p
;
4403 struct glyph
*glyph
, *last
;
4405 int glyph_not_available_p
;
4407 xassert (s
->f
== XFRAME (s
->w
->frame
));
4408 xassert (s
->nchars
== 0);
4409 xassert (start
>= 0 && end
> start
);
4411 s
->for_overlaps_p
= overlaps_p
,
4412 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4413 last
= s
->row
->glyphs
[s
->area
] + end
;
4414 voffset
= glyph
->voffset
;
4416 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4419 && glyph
->type
== CHAR_GLYPH
4420 && glyph
->voffset
== voffset
4421 /* Same face id implies same font, nowadays. */
4422 && glyph
->face_id
== face_id
4423 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4427 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4428 s
->char2b
+ s
->nchars
,
4430 s
->two_byte_p
= two_byte_p
;
4432 xassert (s
->nchars
<= end
- start
);
4433 s
->width
+= glyph
->pixel_width
;
4437 s
->font
= s
->face
->font
;
4438 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4440 /* If the specified font could not be loaded, use the frame's font,
4441 but record the fact that we couldn't load it in
4442 S->font_not_found_p so that we can draw rectangles for the
4443 characters of the glyph string. */
4444 if (s
->font
== NULL
|| glyph_not_available_p
)
4446 s
->font_not_found_p
= 1;
4447 s
->font
= FRAME_FONT (s
->f
);
4450 /* Adjust base line for subscript/superscript text. */
4451 s
->ybase
+= voffset
;
4453 xassert (s
->face
&& s
->face
->gc
);
4454 return glyph
- s
->row
->glyphs
[s
->area
];
4458 /* Fill glyph string S from image glyph S->first_glyph. */
4461 x_fill_image_glyph_string (s
)
4462 struct glyph_string
*s
;
4464 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4465 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4467 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4468 s
->font
= s
->face
->font
;
4469 s
->width
= s
->first_glyph
->pixel_width
;
4471 /* Adjust base line for subscript/superscript text. */
4472 s
->ybase
+= s
->first_glyph
->voffset
;
4476 /* Fill glyph string S from a sequence of stretch glyphs.
4478 ROW is the glyph row in which the glyphs are found, AREA is the
4479 area within the row. START is the index of the first glyph to
4480 consider, END is the index of the last + 1.
4482 Value is the index of the first glyph not in S. */
4485 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4486 struct glyph_string
*s
;
4487 struct glyph_row
*row
;
4488 enum glyph_row_area area
;
4491 struct glyph
*glyph
, *last
;
4492 int voffset
, face_id
;
4494 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4496 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4497 last
= s
->row
->glyphs
[s
->area
] + end
;
4498 face_id
= glyph
->face_id
;
4499 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4500 s
->font
= s
->face
->font
;
4501 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4502 s
->width
= glyph
->pixel_width
;
4503 voffset
= glyph
->voffset
;
4507 && glyph
->type
== STRETCH_GLYPH
4508 && glyph
->voffset
== voffset
4509 && glyph
->face_id
== face_id
);
4511 s
->width
+= glyph
->pixel_width
;
4513 /* Adjust base line for subscript/superscript text. */
4514 s
->ybase
+= voffset
;
4516 xassert (s
->face
&& s
->face
->gc
);
4517 return glyph
- s
->row
->glyphs
[s
->area
];
4521 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4522 of XChar2b structures for S; it can't be allocated in
4523 x_init_glyph_string because it must be allocated via `alloca'. W
4524 is the window on which S is drawn. ROW and AREA are the glyph row
4525 and area within the row from which S is constructed. START is the
4526 index of the first glyph structure covered by S. HL is a
4527 face-override for drawing S. */
4530 x_init_glyph_string (s
, char2b
, w
, row
, area
, start
, hl
)
4531 struct glyph_string
*s
;
4534 struct glyph_row
*row
;
4535 enum glyph_row_area area
;
4537 enum draw_glyphs_face hl
;
4539 bzero (s
, sizeof *s
);
4541 s
->f
= XFRAME (w
->frame
);
4542 s
->display
= FRAME_X_DISPLAY (s
->f
);
4543 s
->window
= FRAME_X_WINDOW (s
->f
);
4548 s
->first_glyph
= row
->glyphs
[area
] + start
;
4549 s
->height
= row
->height
;
4550 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4552 /* Display the internal border below the tool-bar window. */
4553 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4554 s
->y
-= s
->f
->output_data
.x
->internal_border_width
;
4556 s
->ybase
= s
->y
+ row
->ascent
;
4560 /* Set background width of glyph string S. START is the index of the
4561 first glyph following S. LAST_X is the right-most x-position + 1
4562 in the drawing area. */
4565 x_set_glyph_string_background_width (s
, start
, last_x
)
4566 struct glyph_string
*s
;
4570 /* If the face of this glyph string has to be drawn to the end of
4571 the drawing area, set S->extends_to_end_of_line_p. */
4572 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4574 if (start
== s
->row
->used
[s
->area
]
4575 && s
->hl
== DRAW_NORMAL_TEXT
4576 && ((s
->area
== TEXT_AREA
&& s
->row
->fill_line_p
)
4577 || s
->face
->background
!= default_face
->background
4578 || s
->face
->stipple
!= default_face
->stipple
))
4579 s
->extends_to_end_of_line_p
= 1;
4581 /* If S extends its face to the end of the line, set its
4582 background_width to the distance to the right edge of the drawing
4584 if (s
->extends_to_end_of_line_p
)
4585 s
->background_width
= last_x
- s
->x
+ 1;
4587 s
->background_width
= s
->width
;
4591 /* Add a glyph string for a stretch glyph to the list of strings
4592 between HEAD and TAIL. START is the index of the stretch glyph in
4593 row area AREA of glyph row ROW. END is the index of the last glyph
4594 in that glyph row area. X is the current output position assigned
4595 to the new glyph string constructed. HL overrides that face of the
4596 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4597 is the right-most x-position of the drawing area. */
4599 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4600 and below -- keep them on one line. */
4601 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4604 s = (struct glyph_string *) alloca (sizeof *s); \
4605 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4606 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4607 x_append_glyph_string (&HEAD, &TAIL, s); \
4613 /* Add a glyph string for an image glyph to the list of strings
4614 between HEAD and TAIL. START is the index of the image glyph in
4615 row area AREA of glyph row ROW. END is the index of the last glyph
4616 in that glyph row area. X is the current output position assigned
4617 to the new glyph string constructed. HL overrides that face of the
4618 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4619 is the right-most x-position of the drawing area. */
4621 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4624 s = (struct glyph_string *) alloca (sizeof *s); \
4625 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4626 x_fill_image_glyph_string (s); \
4627 x_append_glyph_string (&HEAD, &TAIL, s); \
4634 /* Add a glyph string for a sequence of character glyphs to the list
4635 of strings between HEAD and TAIL. START is the index of the first
4636 glyph in row area AREA of glyph row ROW that is part of the new
4637 glyph string. END is the index of the last glyph in that glyph row
4638 area. X is the current output position assigned to the new glyph
4639 string constructed. HL overrides that face of the glyph; e.g. it
4640 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4641 right-most x-position of the drawing area. */
4643 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4649 c = (ROW)->glyphs[AREA][START].u.ch; \
4650 face_id = (ROW)->glyphs[AREA][START].face_id; \
4652 s = (struct glyph_string *) alloca (sizeof *s); \
4653 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4654 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4655 x_append_glyph_string (&HEAD, &TAIL, s); \
4657 START = x_fill_glyph_string (s, face_id, START, END, \
4663 /* Add a glyph string for a composite sequence to the list of strings
4664 between HEAD and TAIL. START is the index of the first glyph in
4665 row area AREA of glyph row ROW that is part of the new glyph
4666 string. END is the index of the last glyph in that glyph row area.
4667 X is the current output position assigned to the new glyph string
4668 constructed. HL overrides that face of the glyph; e.g. it is
4669 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4670 x-position of the drawing area. */
4672 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4674 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4675 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4676 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4677 struct composition *cmp = composition_table[cmp_id]; \
4678 int glyph_len = cmp->glyph_len; \
4680 struct face **faces; \
4681 struct glyph_string *first_s = NULL; \
4684 base_face = base_face->ascii_face; \
4685 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4686 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4687 /* At first, fill in `char2b' and `faces'. */ \
4688 for (n = 0; n < glyph_len; n++) \
4690 int c = COMPOSITION_GLYPH (cmp, n); \
4691 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4692 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4693 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4694 this_face_id, char2b + n, 1); \
4697 /* Make glyph_strings for each glyph sequence that is drawable by \
4698 the same face, and append them to HEAD/TAIL. */ \
4699 for (n = 0; n < cmp->glyph_len;) \
4701 s = (struct glyph_string *) alloca (sizeof *s); \
4702 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
4703 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4711 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4719 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4720 of AREA of glyph row ROW on window W between indices START and END.
4721 HL overrides the face for drawing glyph strings, e.g. it is
4722 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4723 x-positions of the drawing area.
4725 This is an ugly monster macro construct because we must use alloca
4726 to allocate glyph strings (because x_draw_glyphs can be called
4729 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4732 HEAD = TAIL = NULL; \
4733 while (START < END) \
4735 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4736 switch (first_glyph->type) \
4739 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
4740 TAIL, HL, X, LAST_X, \
4744 case COMPOSITE_GLYPH: \
4745 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
4746 HEAD, TAIL, HL, X, LAST_X,\
4750 case STRETCH_GLYPH: \
4751 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
4752 HEAD, TAIL, HL, X, LAST_X); \
4756 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
4757 TAIL, HL, X, LAST_X); \
4764 x_set_glyph_string_background_width (s, START, LAST_X); \
4771 /* Draw glyphs between START and END in AREA of ROW on window W,
4772 starting at x-position X. X is relative to AREA in W. HL is a
4773 face-override with the following meaning:
4775 DRAW_NORMAL_TEXT draw normally
4776 DRAW_CURSOR draw in cursor face
4777 DRAW_MOUSE_FACE draw in mouse face.
4778 DRAW_INVERSE_VIDEO draw in mode line face
4779 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
4780 DRAW_IMAGE_RAISED draw an image with a raised relief around it
4782 If REAL_START is non-null, return in *REAL_START the real starting
4783 position for display. This can be different from START in case
4784 overlapping glyphs must be displayed. If REAL_END is non-null,
4785 return in *REAL_END the real end position for display. This can be
4786 different from END in case overlapping glyphs must be displayed.
4788 If OVERLAPS_P is non-zero, draw only the foreground of characters
4789 and clip to the physical height of ROW.
4791 Value is the x-position reached, relative to AREA of W. */
4794 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, real_start
, real_end
,
4798 struct glyph_row
*row
;
4799 enum glyph_row_area area
;
4801 enum draw_glyphs_face hl
;
4802 int *real_start
, *real_end
;
4805 struct glyph_string
*head
, *tail
;
4806 struct glyph_string
*s
;
4807 int last_x
, area_width
;
4811 /* Let's rather be paranoid than getting a SEGV. */
4812 end
= min (end
, row
->used
[area
]);
4813 start
= max (0, start
);
4814 start
= min (end
, start
);
4816 *real_start
= start
;
4820 /* Translate X to frame coordinates. Set last_x to the right
4821 end of the drawing area. */
4822 if (row
->full_width_p
)
4824 /* X is relative to the left edge of W, without scroll bars
4826 struct frame
*f
= XFRAME (w
->frame
);
4827 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
4828 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
4831 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4832 last_x
= window_left_x
+ area_width
;
4834 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4836 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4837 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4843 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
4844 last_x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
4848 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
4849 area_width
= window_box_width (w
, area
);
4850 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
4853 /* Build a doubly-linked list of glyph_string structures between
4854 head and tail from what we have to draw. Note that the macro
4855 BUILD_GLYPH_STRINGS will modify its start parameter. That's
4856 the reason we use a separate variable `i'. */
4858 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
4861 x_reached
= tail
->x
+ tail
->background_width
;
4865 /* If there are any glyphs with lbearing < 0 or rbearing > width in
4866 the row, redraw some glyphs in front or following the glyph
4867 strings built above. */
4868 if (head
&& !overlaps_p
&& row
->contains_overlapping_glyphs_p
)
4871 struct glyph_string
*h
, *t
;
4873 /* Compute overhangs for all glyph strings. */
4874 for (s
= head
; s
; s
= s
->next
)
4875 x_compute_glyph_string_overhangs (s
);
4877 /* Prepend glyph strings for glyphs in front of the first glyph
4878 string that are overwritten because of the first glyph
4879 string's left overhang. The background of all strings
4880 prepended must be drawn because the first glyph string
4882 i
= x_left_overwritten (head
);
4886 BUILD_GLYPH_STRINGS (w
, row
, area
, j
, start
, h
, t
,
4887 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4891 *real_start
= start
;
4892 x_compute_overhangs_and_x (t
, head
->x
, 1);
4893 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4896 /* Prepend glyph strings for glyphs in front of the first glyph
4897 string that overwrite that glyph string because of their
4898 right overhang. For these strings, only the foreground must
4899 be drawn, because it draws over the glyph string at `head'.
4900 The background must not be drawn because this would overwrite
4901 right overhangs of preceding glyphs for which no glyph
4903 i
= x_left_overwriting (head
);
4906 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, start
, h
, t
,
4907 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4909 for (s
= h
; s
; s
= s
->next
)
4910 s
->background_filled_p
= 1;
4913 x_compute_overhangs_and_x (t
, head
->x
, 1);
4914 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4917 /* Append glyphs strings for glyphs following the last glyph
4918 string tail that are overwritten by tail. The background of
4919 these strings has to be drawn because tail's foreground draws
4921 i
= x_right_overwritten (tail
);
4924 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
4925 DRAW_NORMAL_TEXT
, x
, last_x
,
4927 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4928 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4933 /* Append glyph strings for glyphs following the last glyph
4934 string tail that overwrite tail. The foreground of such
4935 glyphs has to be drawn because it writes into the background
4936 of tail. The background must not be drawn because it could
4937 paint over the foreground of following glyphs. */
4938 i
= x_right_overwriting (tail
);
4941 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
4942 DRAW_NORMAL_TEXT
, x
, last_x
,
4944 for (s
= h
; s
; s
= s
->next
)
4945 s
->background_filled_p
= 1;
4946 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4947 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4953 /* Draw all strings. */
4954 for (s
= head
; s
; s
= s
->next
)
4955 x_draw_glyph_string (s
);
4957 /* Value is the x-position up to which drawn, relative to AREA of W.
4958 This doesn't include parts drawn because of overhangs. */
4959 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
4960 if (!row
->full_width_p
)
4962 if (area
> LEFT_MARGIN_AREA
)
4963 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
4964 if (area
> TEXT_AREA
)
4965 x_reached
-= window_box_width (w
, TEXT_AREA
);
4972 /* Fix the display of area AREA of overlapping row ROW in window W. */
4975 x_fix_overlapping_area (w
, row
, area
)
4977 struct glyph_row
*row
;
4978 enum glyph_row_area area
;
4984 if (area
== LEFT_MARGIN_AREA
)
4986 else if (area
== TEXT_AREA
)
4987 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
4989 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
4990 + window_box_width (w
, TEXT_AREA
));
4992 for (i
= 0; i
< row
->used
[area
];)
4994 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
4996 int start
= i
, start_x
= x
;
5000 x
+= row
->glyphs
[area
][i
].pixel_width
;
5003 while (i
< row
->used
[area
]
5004 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5006 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5008 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5013 x
+= row
->glyphs
[area
][i
].pixel_width
;
5022 /* Output LEN glyphs starting at START at the nominal cursor position.
5023 Advance the nominal cursor over the text. The global variable
5024 updated_window contains the window being updated, updated_row is
5025 the glyph row being updated, and updated_area is the area of that
5026 row being updated. */
5029 x_write_glyphs (start
, len
)
5030 struct glyph
*start
;
5033 int x
, hpos
, real_start
, real_end
;
5035 xassert (updated_window
&& updated_row
);
5040 hpos
= start
- updated_row
->glyphs
[updated_area
];
5041 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5042 updated_row
, updated_area
,
5044 (updated_row
->inverse_p
5045 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5046 &real_start
, &real_end
, 0);
5048 /* If we drew over the cursor, note that it is not visible any more. */
5049 note_overwritten_text_cursor (updated_window
, real_start
,
5050 real_end
- real_start
);
5054 /* Advance the output cursor. */
5055 output_cursor
.hpos
+= len
;
5056 output_cursor
.x
= x
;
5060 /* Insert LEN glyphs from START at the nominal cursor position. */
5063 x_insert_glyphs (start
, len
)
5064 struct glyph
*start
;
5069 int line_height
, shift_by_width
, shifted_region_width
;
5070 struct glyph_row
*row
;
5071 struct glyph
*glyph
;
5072 int frame_x
, frame_y
, hpos
, real_start
, real_end
;
5074 xassert (updated_window
&& updated_row
);
5077 f
= XFRAME (WINDOW_FRAME (w
));
5079 /* Get the height of the line we are in. */
5081 line_height
= row
->height
;
5083 /* Get the width of the glyphs to insert. */
5085 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5086 shift_by_width
+= glyph
->pixel_width
;
5088 /* Get the width of the region to shift right. */
5089 shifted_region_width
= (window_box_width (w
, updated_area
)
5094 frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, output_cursor
.x
);
5095 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5096 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5097 f
->output_data
.x
->normal_gc
,
5099 shifted_region_width
, line_height
,
5100 frame_x
+ shift_by_width
, frame_y
);
5102 /* Write the glyphs. */
5103 hpos
= start
- row
->glyphs
[updated_area
];
5104 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5105 DRAW_NORMAL_TEXT
, &real_start
, &real_end
, 0);
5106 note_overwritten_text_cursor (w
, real_start
, real_end
- real_start
);
5108 /* Advance the output cursor. */
5109 output_cursor
.hpos
+= len
;
5110 output_cursor
.x
+= shift_by_width
;
5115 /* Delete N glyphs at the nominal cursor position. Not implemented
5126 /* Erase the current text line from the nominal cursor position
5127 (inclusive) to pixel column TO_X (exclusive). The idea is that
5128 everything from TO_X onward is already erased.
5130 TO_X is a pixel position relative to updated_area of
5131 updated_window. TO_X == -1 means clear to the end of this area. */
5134 x_clear_end_of_line (to_x
)
5138 struct window
*w
= updated_window
;
5139 int max_x
, min_y
, max_y
;
5140 int from_x
, from_y
, to_y
;
5142 xassert (updated_window
&& updated_row
);
5143 f
= XFRAME (w
->frame
);
5145 if (updated_row
->full_width_p
)
5147 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5148 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5149 && !w
->pseudo_window_p
)
5150 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5153 max_x
= window_box_width (w
, updated_area
);
5154 max_y
= window_text_bottom_y (w
);
5156 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5157 of window. For TO_X > 0, truncate to end of drawing area. */
5163 to_x
= min (to_x
, max_x
);
5165 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5167 /* Notice if the cursor will be cleared by this operation. */
5168 if (!updated_row
->full_width_p
)
5169 note_overwritten_text_cursor (w
, output_cursor
.hpos
, -1);
5171 from_x
= output_cursor
.x
;
5173 /* Translate to frame coordinates. */
5174 if (updated_row
->full_width_p
)
5176 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5177 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5181 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5182 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5185 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5186 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5187 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5189 /* Prevent inadvertently clearing to end of the X window. */
5190 if (to_x
> from_x
&& to_y
> from_y
)
5193 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5194 from_x
, from_y
, to_x
- from_x
, to_y
- from_y
,
5201 /* Clear entire frame. If updating_frame is non-null, clear that
5202 frame. Otherwise clear the selected frame. */
5212 f
= SELECTED_FRAME ();
5214 /* Clearing the frame will erase any cursor, so mark them all as no
5216 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5217 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5218 output_cursor
.x
= -1;
5220 /* We don't set the output cursor here because there will always
5221 follow an explicit cursor_to. */
5223 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5225 /* We have to clear the scroll bars, too. If we have changed
5226 colors or something like that, then they should be notified. */
5227 x_scroll_bar_clear (f
);
5229 XFlush (FRAME_X_DISPLAY (f
));
5235 /* Invert the middle quarter of the frame for .15 sec. */
5237 /* We use the select system call to do the waiting, so we have to make
5238 sure it's available. If it isn't, we just won't do visual bells. */
5240 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5243 /* Subtract the `struct timeval' values X and Y, storing the result in
5244 *RESULT. Return 1 if the difference is negative, otherwise 0. */
5247 timeval_subtract (result
, x
, y
)
5248 struct timeval
*result
, x
, y
;
5250 /* Perform the carry for the later subtraction by updating y. This
5251 is safer because on some systems the tv_sec member is unsigned. */
5252 if (x
.tv_usec
< y
.tv_usec
)
5254 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
5255 y
.tv_usec
-= 1000000 * nsec
;
5259 if (x
.tv_usec
- y
.tv_usec
> 1000000)
5261 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
5262 y
.tv_usec
+= 1000000 * nsec
;
5266 /* Compute the time remaining to wait. tv_usec is certainly
5268 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
5269 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
5271 /* Return indication of whether the result should be considered
5273 return x
.tv_sec
< y
.tv_sec
;
5285 /* Create a GC that will use the GXxor function to flip foreground
5286 pixels into background pixels. */
5290 values
.function
= GXxor
;
5291 values
.foreground
= (f
->output_data
.x
->foreground_pixel
5292 ^ f
->output_data
.x
->background_pixel
);
5294 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5295 GCFunction
| GCForeground
, &values
);
5299 /* Get the height not including a menu bar widget. */
5300 int height
= CHAR_TO_PIXEL_HEIGHT (f
, FRAME_HEIGHT (f
));
5301 /* Height of each line to flash. */
5302 int flash_height
= FRAME_LINE_HEIGHT (f
);
5303 /* These will be the left and right margins of the rectangles. */
5304 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
5305 int flash_right
= PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
5309 /* Don't flash the area between a scroll bar and the frame
5310 edge it is next to. */
5311 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
5313 case vertical_scroll_bar_left
:
5314 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5317 case vertical_scroll_bar_right
:
5318 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5325 width
= flash_right
- flash_left
;
5327 /* If window is tall, flash top and bottom line. */
5328 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5330 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5332 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5333 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5334 width
, flash_height
);
5335 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5337 (height
- flash_height
5338 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5339 width
, flash_height
);
5342 /* If it is short, flash it all. */
5343 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5344 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5345 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5350 struct timeval wakeup
;
5352 EMACS_GET_TIME (wakeup
);
5354 /* Compute time to wait until, propagating carry from usecs. */
5355 wakeup
.tv_usec
+= 150000;
5356 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
5357 wakeup
.tv_usec
%= 1000000;
5359 /* Keep waiting until past the time wakeup. */
5362 struct timeval timeout
;
5364 EMACS_GET_TIME (timeout
);
5366 /* In effect, timeout = wakeup - timeout.
5367 Break if result would be negative. */
5368 if (timeval_subtract (&timeout
, wakeup
, timeout
))
5371 /* Try to wait that long--but we might wake up sooner. */
5372 select (0, NULL
, NULL
, NULL
, &timeout
);
5376 /* If window is tall, flash top and bottom line. */
5377 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5379 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5381 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5382 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5383 width
, flash_height
);
5384 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5386 (height
- flash_height
5387 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5388 width
, flash_height
);
5391 /* If it is short, flash it all. */
5392 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5393 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5394 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5396 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5404 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5407 /* Make audible bell. */
5412 struct frame
*f
= SELECTED_FRAME ();
5414 if (FRAME_X_DISPLAY (f
))
5416 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5423 XBell (FRAME_X_DISPLAY (f
), 0);
5424 XFlush (FRAME_X_DISPLAY (f
));
5431 /* Specify how many text lines, from the top of the window,
5432 should be affected by insert-lines and delete-lines operations.
5433 This, and those operations, are used only within an update
5434 that is bounded by calls to x_update_begin and x_update_end. */
5437 XTset_terminal_window (n
)
5440 /* This function intentionally left blank. */
5445 /***********************************************************************
5447 ***********************************************************************/
5449 /* Perform an insert-lines or delete-lines operation, inserting N
5450 lines or deleting -N lines at vertical position VPOS. */
5453 x_ins_del_lines (vpos
, n
)
5460 /* Scroll part of the display as described by RUN. */
5463 x_scroll_run (w
, run
)
5467 struct frame
*f
= XFRAME (w
->frame
);
5468 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5470 /* Get frame-relative bounding box of the text display area of W,
5471 without mode lines. Include in this box the flags areas to the
5472 left and right of W. */
5473 window_box (w
, -1, &x
, &y
, &width
, &height
);
5474 width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
5475 x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
5477 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5478 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5479 bottom_y
= y
+ height
;
5483 /* Scrolling up. Make sure we don't copy part of the mode
5484 line at the bottom. */
5485 if (from_y
+ run
->height
> bottom_y
)
5486 height
= bottom_y
- from_y
;
5488 height
= run
->height
;
5492 /* Scolling down. Make sure we don't copy over the mode line.
5494 if (to_y
+ run
->height
> bottom_y
)
5495 height
= bottom_y
- to_y
;
5497 height
= run
->height
;
5502 /* Cursor off. Will be switched on again in x_update_window_end. */
5506 XCopyArea (FRAME_X_DISPLAY (f
),
5507 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5508 f
->output_data
.x
->normal_gc
,
5518 /***********************************************************************
5520 ***********************************************************************/
5522 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5523 corner of the exposed rectangle. W and H are width and height of
5524 the exposed area. All are pixel values. W or H zero means redraw
5525 the entire frame. */
5528 expose_frame (f
, x
, y
, w
, h
)
5534 TRACE ((stderr
, "expose_frame "));
5536 /* No need to redraw if frame will be redrawn soon. */
5537 if (FRAME_GARBAGED_P (f
))
5539 TRACE ((stderr
, " garbaged\n"));
5543 /* If basic faces haven't been realized yet, there is no point in
5544 trying to redraw anything. This can happen when we get an expose
5545 event while Emacs is starting, e.g. by moving another window. */
5546 if (FRAME_FACE_CACHE (f
) == NULL
5547 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5549 TRACE ((stderr
, " no faces\n"));
5553 if (w
== 0 || h
== 0)
5556 r
.width
= CANON_X_UNIT (f
) * f
->width
;
5557 r
.height
= CANON_Y_UNIT (f
) * f
->height
;
5567 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
5568 expose_window_tree (XWINDOW (f
->root_window
), &r
);
5570 if (WINDOWP (f
->tool_bar_window
))
5572 struct window
*w
= XWINDOW (f
->tool_bar_window
);
5573 XRectangle window_rect
;
5574 XRectangle intersection_rect
;
5575 int window_x
, window_y
, window_width
, window_height
;
5578 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5579 window_rect
.x
= window_x
;
5580 window_rect
.y
= window_y
;
5581 window_rect
.width
= window_width
;
5582 window_rect
.height
= window_height
;
5584 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5585 expose_window (w
, &intersection_rect
);
5588 #ifndef USE_X_TOOLKIT
5589 if (WINDOWP (f
->menu_bar_window
))
5591 struct window
*w
= XWINDOW (f
->menu_bar_window
);
5592 XRectangle window_rect
;
5593 XRectangle intersection_rect
;
5594 int window_x
, window_y
, window_width
, window_height
;
5597 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5598 window_rect
.x
= window_x
;
5599 window_rect
.y
= window_y
;
5600 window_rect
.width
= window_width
;
5601 window_rect
.height
= window_height
;
5603 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5604 expose_window (w
, &intersection_rect
);
5606 #endif /* not USE_X_TOOLKIT */
5610 /* Redraw (parts) of all windows in the window tree rooted at W that
5611 intersect R. R contains frame pixel coordinates. */
5614 expose_window_tree (w
, r
)
5620 if (!NILP (w
->hchild
))
5621 expose_window_tree (XWINDOW (w
->hchild
), r
);
5622 else if (!NILP (w
->vchild
))
5623 expose_window_tree (XWINDOW (w
->vchild
), r
);
5626 XRectangle window_rect
;
5627 XRectangle intersection_rect
;
5628 struct frame
*f
= XFRAME (w
->frame
);
5629 int window_x
, window_y
, window_width
, window_height
;
5631 /* Frame-relative pixel rectangle of W. */
5632 window_box (w
, -1, &window_x
, &window_y
, &window_width
,
5636 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
5637 - FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5638 window_rect
.y
= window_y
;
5641 + FRAME_X_FLAGS_AREA_WIDTH (f
)
5642 + FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5644 = window_height
+ CURRENT_MODE_LINE_HEIGHT (w
);
5646 if (x_intersect_rectangles (r
, &window_rect
, &intersection_rect
))
5647 expose_window (w
, &intersection_rect
);
5650 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5655 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5656 which intersects rectangle R. R is in window-relative coordinates. */
5659 expose_area (w
, row
, r
, area
)
5661 struct glyph_row
*row
;
5663 enum glyph_row_area area
;
5666 struct glyph
*first
= row
->glyphs
[area
];
5667 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5671 /* Set x to the window-relative start position for drawing glyphs of
5672 AREA. The first glyph of the text area can be partially visible.
5673 The first glyphs of other areas cannot. */
5674 if (area
== LEFT_MARGIN_AREA
)
5676 else if (area
== TEXT_AREA
)
5677 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5679 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5680 + window_box_width (w
, TEXT_AREA
));
5682 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5683 /* If row extends face to end of line write the whole line. */
5684 x_draw_glyphs (w
, x
, row
, area
,
5686 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5690 /* Find the first glyph that must be redrawn. */
5692 && x
+ first
->pixel_width
< r
->x
)
5694 x
+= first
->pixel_width
;
5698 /* Find the last one. */
5702 && x
< r
->x
+ r
->width
)
5704 x
+= last
->pixel_width
;
5710 x_draw_glyphs (w
, first_x
, row
, area
,
5711 first
- row
->glyphs
[area
],
5712 last
- row
->glyphs
[area
],
5713 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5719 /* Redraw the parts of the glyph row ROW on window W intersecting
5720 rectangle R. R is in window-relative coordinates. */
5723 expose_line (w
, row
, r
)
5725 struct glyph_row
*row
;
5728 xassert (row
->enabled_p
);
5730 if (row
->mode_line_p
|| w
->pseudo_window_p
)
5731 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
5732 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5736 if (row
->used
[LEFT_MARGIN_AREA
])
5737 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
5738 if (row
->used
[TEXT_AREA
])
5739 expose_area (w
, row
, r
, TEXT_AREA
);
5740 if (row
->used
[RIGHT_MARGIN_AREA
])
5741 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
5742 x_draw_row_bitmaps (w
, row
);
5747 /* Return non-zero if W's cursor intersects rectangle R. */
5750 x_phys_cursor_in_rect_p (w
, r
)
5754 XRectangle cr
, result
;
5755 struct glyph
*cursor_glyph
;
5757 cursor_glyph
= get_phys_cursor_glyph (w
);
5760 cr
.x
= w
->phys_cursor
.x
;
5761 cr
.y
= w
->phys_cursor
.y
;
5762 cr
.width
= cursor_glyph
->pixel_width
;
5763 cr
.height
= w
->phys_cursor_height
;
5764 return x_intersect_rectangles (&cr
, r
, &result
);
5771 /* Redraw a rectangle of window W. R is a rectangle in window
5772 relative coordinates. Call this function with input blocked. */
5775 expose_window (w
, r
)
5779 struct glyph_row
*row
;
5781 int yb
= window_text_bottom_y (w
);
5782 int cursor_cleared_p
;
5784 /* If window is not yet fully initialized, do nothing. This can
5785 happen when toolkit scroll bars are used and a window is split.
5786 Reconfiguring the scroll bar will generate an expose for a newly
5788 if (w
->current_matrix
== NULL
)
5791 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
5792 r
->x
, r
->y
, r
->width
, r
->height
));
5794 /* Convert to window coordinates. */
5795 r
->x
= FRAME_TO_WINDOW_PIXEL_X (w
, r
->x
);
5796 r
->y
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
->y
);
5798 /* Turn off the cursor. */
5799 if (!w
->pseudo_window_p
5800 && x_phys_cursor_in_rect_p (w
, r
))
5803 cursor_cleared_p
= 1;
5806 cursor_cleared_p
= 0;
5808 /* Find the first row intersecting the rectangle R. */
5809 row
= w
->current_matrix
->rows
;
5811 while (row
->enabled_p
5813 && y
+ row
->height
< r
->y
)
5819 /* Display the text in the rectangle, one text line at a time. */
5820 while (row
->enabled_p
5822 && y
< r
->y
+ r
->height
)
5824 expose_line (w
, row
, r
);
5829 /* Display the mode line if there is one. */
5830 if (WINDOW_WANTS_MODELINE_P (w
)
5831 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
5833 && row
->y
< r
->y
+ r
->height
)
5834 expose_line (w
, row
, r
);
5836 if (!w
->pseudo_window_p
)
5838 /* Draw border between windows. */
5839 x_draw_vertical_border (w
);
5841 /* Turn the cursor on again. */
5842 if (cursor_cleared_p
)
5843 x_update_window_cursor (w
, 1);
5848 /* Determine the intersection of two rectangles R1 and R2. Return
5849 the intersection in *RESULT. Value is non-zero if RESULT is not
5853 x_intersect_rectangles (r1
, r2
, result
)
5854 XRectangle
*r1
, *r2
, *result
;
5856 XRectangle
*left
, *right
;
5857 XRectangle
*upper
, *lower
;
5858 int intersection_p
= 0;
5860 /* Rearrange so that R1 is the left-most rectangle. */
5862 left
= r1
, right
= r2
;
5864 left
= r2
, right
= r1
;
5866 /* X0 of the intersection is right.x0, if this is inside R1,
5867 otherwise there is no intersection. */
5868 if (right
->x
<= left
->x
+ left
->width
)
5870 result
->x
= right
->x
;
5872 /* The right end of the intersection is the minimum of the
5873 the right ends of left and right. */
5874 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
5877 /* Same game for Y. */
5879 upper
= r1
, lower
= r2
;
5881 upper
= r2
, lower
= r1
;
5883 /* The upper end of the intersection is lower.y0, if this is inside
5884 of upper. Otherwise, there is no intersection. */
5885 if (lower
->y
<= upper
->y
+ upper
->height
)
5887 result
->y
= lower
->y
;
5889 /* The lower end of the intersection is the minimum of the lower
5890 ends of upper and lower. */
5891 result
->height
= (min (lower
->y
+ lower
->height
,
5892 upper
->y
+ upper
->height
)
5898 return intersection_p
;
5909 /* We used to only do this if Vx_no_window_manager was non-nil, but
5910 the ICCCM (section 4.1.6) says that the window's border pixmap
5911 and border pixel are window attributes which are "private to the
5912 client", so we can always change it to whatever we want. */
5914 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5915 f
->output_data
.x
->border_pixel
);
5917 x_update_cursor (f
, 1);
5921 frame_unhighlight (f
)
5924 /* We used to only do this if Vx_no_window_manager was non-nil, but
5925 the ICCCM (section 4.1.6) says that the window's border pixmap
5926 and border pixel are window attributes which are "private to the
5927 client", so we can always change it to whatever we want. */
5929 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5930 f
->output_data
.x
->border_tile
);
5932 x_update_cursor (f
, 1);
5935 /* The focus has changed. Update the frames as necessary to reflect
5936 the new situation. Note that we can't change the selected frame
5937 here, because the Lisp code we are interrupting might become confused.
5938 Each event gets marked with the frame in which it occurred, so the
5939 Lisp code can tell when the switch took place by examining the events. */
5942 x_new_focus_frame (dpyinfo
, frame
)
5943 struct x_display_info
*dpyinfo
;
5944 struct frame
*frame
;
5946 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
5948 if (frame
!= dpyinfo
->x_focus_frame
)
5950 /* Set this before calling other routines, so that they see
5951 the correct value of x_focus_frame. */
5952 dpyinfo
->x_focus_frame
= frame
;
5954 if (old_focus
&& old_focus
->auto_lower
)
5955 x_lower_frame (old_focus
);
5958 selected_frame
= frame
;
5959 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
5961 Fselect_window (selected_frame
->selected_window
);
5962 choose_minibuf_frame ();
5965 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
5966 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
5968 pending_autoraise_frame
= 0;
5971 x_frame_rehighlight (dpyinfo
);
5974 /* Handle an event saying the mouse has moved out of an Emacs frame. */
5977 x_mouse_leave (dpyinfo
)
5978 struct x_display_info
*dpyinfo
;
5980 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
5983 /* The focus has changed, or we have redirected a frame's focus to
5984 another frame (this happens when a frame uses a surrogate
5985 mini-buffer frame). Shift the highlight as appropriate.
5987 The FRAME argument doesn't necessarily have anything to do with which
5988 frame is being highlighted or un-highlighted; we only use it to find
5989 the appropriate X display info. */
5992 XTframe_rehighlight (frame
)
5993 struct frame
*frame
;
5995 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
5999 x_frame_rehighlight (dpyinfo
)
6000 struct x_display_info
*dpyinfo
;
6002 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
6004 if (dpyinfo
->x_focus_frame
)
6006 dpyinfo
->x_highlight_frame
6007 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
6008 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
6009 : dpyinfo
->x_focus_frame
);
6010 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
6012 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
6013 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
6017 dpyinfo
->x_highlight_frame
= 0;
6019 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
6022 frame_unhighlight (old_highlight
);
6023 if (dpyinfo
->x_highlight_frame
)
6024 frame_highlight (dpyinfo
->x_highlight_frame
);
6030 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
6032 /* Initialize mode_switch_bit and modifier_meaning. */
6034 x_find_modifier_meanings (dpyinfo
)
6035 struct x_display_info
*dpyinfo
;
6037 int min_code
, max_code
;
6040 XModifierKeymap
*mods
;
6042 dpyinfo
->meta_mod_mask
= 0;
6043 dpyinfo
->shift_lock_mask
= 0;
6044 dpyinfo
->alt_mod_mask
= 0;
6045 dpyinfo
->super_mod_mask
= 0;
6046 dpyinfo
->hyper_mod_mask
= 0;
6049 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
6051 min_code
= dpyinfo
->display
->min_keycode
;
6052 max_code
= dpyinfo
->display
->max_keycode
;
6055 syms
= XGetKeyboardMapping (dpyinfo
->display
,
6056 min_code
, max_code
- min_code
+ 1,
6058 mods
= XGetModifierMapping (dpyinfo
->display
);
6060 /* Scan the modifier table to see which modifier bits the Meta and
6061 Alt keysyms are on. */
6063 int row
, col
; /* The row and column in the modifier table. */
6065 for (row
= 3; row
< 8; row
++)
6066 for (col
= 0; col
< mods
->max_keypermod
; col
++)
6069 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
6071 /* Zeroes are used for filler. Skip them. */
6075 /* Are any of this keycode's keysyms a meta key? */
6079 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
6081 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
6087 dpyinfo
->meta_mod_mask
|= (1 << row
);
6092 dpyinfo
->alt_mod_mask
|= (1 << row
);
6097 dpyinfo
->hyper_mod_mask
|= (1 << row
);
6102 dpyinfo
->super_mod_mask
|= (1 << row
);
6106 /* Ignore this if it's not on the lock modifier. */
6107 if ((1 << row
) == LockMask
)
6108 dpyinfo
->shift_lock_mask
= LockMask
;
6116 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
6117 if (! dpyinfo
->meta_mod_mask
)
6119 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
6120 dpyinfo
->alt_mod_mask
= 0;
6123 /* If some keys are both alt and meta,
6124 make them just meta, not alt. */
6125 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
6127 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
6130 XFree ((char *) syms
);
6131 XFreeModifiermap (mods
);
6134 /* Convert between the modifier bits X uses and the modifier bits
6138 x_x_to_emacs_modifiers (dpyinfo
, state
)
6139 struct x_display_info
*dpyinfo
;
6142 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
6143 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
6144 | ((state
& dpyinfo
->meta_mod_mask
) ? meta_modifier
: 0)
6145 | ((state
& dpyinfo
->alt_mod_mask
) ? alt_modifier
: 0)
6146 | ((state
& dpyinfo
->super_mod_mask
) ? super_modifier
: 0)
6147 | ((state
& dpyinfo
->hyper_mod_mask
) ? hyper_modifier
: 0));
6151 x_emacs_to_x_modifiers (dpyinfo
, state
)
6152 struct x_display_info
*dpyinfo
;
6155 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
6156 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
6157 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
6158 | ((state
& shift_modifier
) ? ShiftMask
: 0)
6159 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
6160 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
6163 /* Convert a keysym to its name. */
6166 x_get_keysym_name (keysym
)
6172 value
= XKeysymToString (keysym
);
6180 /* Mouse clicks and mouse movement. Rah. */
6182 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6183 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6184 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6185 not force the value into range. */
6188 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
6190 register int pix_x
, pix_y
;
6191 register int *x
, *y
;
6195 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6196 even for negative values. */
6198 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
6200 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
6202 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
6203 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
6207 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
6208 bounds
->height
= f
->output_data
.x
->line_height
;
6209 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
6210 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
6217 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
6218 pix_x
= FRAME_WINDOW_WIDTH (f
);
6222 else if (pix_y
> f
->height
)
6231 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6232 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6233 can't tell the positions because W's display is not up to date,
6237 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
6240 int *frame_x
, *frame_y
;
6244 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
6245 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
6247 if (display_completed
)
6249 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6250 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
6251 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
6257 *frame_x
+= glyph
->pixel_width
;
6265 *frame_y
= *frame_x
= 0;
6269 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6270 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6275 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6277 If the event is a button press, then note that we have grabbed
6281 construct_mouse_click (result
, event
, f
)
6282 struct input_event
*result
;
6283 XButtonEvent
*event
;
6286 /* Make the event type no_event; we'll change that when we decide
6288 result
->kind
= mouse_click
;
6289 result
->code
= event
->button
- Button1
;
6290 result
->timestamp
= event
->time
;
6291 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6293 | (event
->type
== ButtonRelease
6297 XSETINT (result
->x
, event
->x
);
6298 XSETINT (result
->y
, event
->y
);
6299 XSETFRAME (result
->frame_or_window
, f
);
6305 /* Function to report a mouse movement to the mainstream Emacs code.
6306 The input handler calls this.
6308 We have received a mouse movement event, which is given in *event.
6309 If the mouse is over a different glyph than it was last time, tell
6310 the mainstream emacs code by setting mouse_moved. If not, ask for
6311 another motion event, so we can check again the next time it moves. */
6313 static XMotionEvent last_mouse_motion_event
;
6314 static Lisp_Object last_mouse_motion_frame
;
6317 note_mouse_movement (frame
, event
)
6319 XMotionEvent
*event
;
6321 last_mouse_movement_time
= event
->time
;
6322 last_mouse_motion_event
= *event
;
6323 XSETFRAME (last_mouse_motion_frame
, frame
);
6325 if (event
->window
!= FRAME_X_WINDOW (frame
))
6327 frame
->mouse_moved
= 1;
6328 last_mouse_scroll_bar
= Qnil
;
6329 note_mouse_highlight (frame
, -1, -1);
6332 /* Has the mouse moved off the glyph it was on at the last sighting? */
6333 else if (event
->x
< last_mouse_glyph
.x
6334 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
6335 || event
->y
< last_mouse_glyph
.y
6336 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
6338 frame
->mouse_moved
= 1;
6339 last_mouse_scroll_bar
= Qnil
;
6340 note_mouse_highlight (frame
, event
->x
, event
->y
);
6344 /* This is used for debugging, to turn off note_mouse_highlight. */
6346 int disable_mouse_highlight
;
6350 /************************************************************************
6352 ************************************************************************/
6354 /* Find the glyph under window-relative coordinates X/Y in window W.
6355 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6356 strings. Return in *HPOS and *VPOS the row and column number of
6357 the glyph found. Return in *AREA the glyph area containing X.
6358 Value is a pointer to the glyph found or null if X/Y is not on
6359 text, or we can't tell because W's current matrix is not up to
6362 static struct glyph
*
6363 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
)
6366 int *hpos
, *vpos
, *area
;
6368 struct glyph
*glyph
, *end
;
6369 struct glyph_row
*row
= NULL
;
6370 int x0
, i
, left_area_width
;
6372 /* Find row containing Y. Give up if some row is not enabled. */
6373 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6375 row
= MATRIX_ROW (w
->current_matrix
, i
);
6376 if (!row
->enabled_p
)
6378 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6385 /* Give up if Y is not in the window. */
6386 if (i
== w
->current_matrix
->nrows
)
6389 /* Get the glyph area containing X. */
6390 if (w
->pseudo_window_p
)
6397 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6398 if (x
< left_area_width
)
6400 *area
= LEFT_MARGIN_AREA
;
6403 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6406 x0
= row
->x
+ left_area_width
;
6410 *area
= RIGHT_MARGIN_AREA
;
6411 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6415 /* Find glyph containing X. */
6416 glyph
= row
->glyphs
[*area
];
6417 end
= glyph
+ row
->used
[*area
];
6420 if (x
< x0
+ glyph
->pixel_width
)
6422 if (w
->pseudo_window_p
)
6424 else if (BUFFERP (glyph
->object
))
6428 x0
+= glyph
->pixel_width
;
6435 *hpos
= glyph
- row
->glyphs
[*area
];
6440 /* Convert frame-relative x/y to coordinates relative to window W.
6441 Takes pseudo-windows into account. */
6444 frame_to_window_pixel_xy (w
, x
, y
)
6448 if (w
->pseudo_window_p
)
6450 /* A pseudo-window is always full-width, and starts at the
6451 left edge of the frame, plus a frame border. */
6452 struct frame
*f
= XFRAME (w
->frame
);
6453 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6454 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6458 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6459 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6464 /* Take proper action when mouse has moved to the mode or top line of
6465 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6466 mode line. X is relative to the start of the text display area of
6467 W, so the width of bitmap areas and scroll bars must be subtracted
6468 to get a position relative to the start of the mode line. */
6471 note_mode_line_highlight (w
, x
, mode_line_p
)
6475 struct frame
*f
= XFRAME (w
->frame
);
6476 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6477 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6478 struct glyph_row
*row
;
6481 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6483 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6487 struct glyph
*glyph
, *end
;
6488 Lisp_Object help
, map
;
6491 /* Find the glyph under X. */
6492 glyph
= row
->glyphs
[TEXT_AREA
];
6493 end
= glyph
+ row
->used
[TEXT_AREA
];
6494 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6495 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
));
6497 && x
>= x0
+ glyph
->pixel_width
)
6499 x0
+= glyph
->pixel_width
;
6504 && STRINGP (glyph
->object
)
6505 && XSTRING (glyph
->object
)->intervals
6506 && glyph
->charpos
>= 0
6507 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6509 /* If we're on a string with `help-echo' text property,
6510 arrange for the help to be displayed. This is done by
6511 setting the global variable help_echo to the help string. */
6512 help
= Fget_text_property (make_number (glyph
->charpos
),
6513 Qhelp_echo
, glyph
->object
);
6517 XSETWINDOW (help_echo_window
, w
);
6518 help_echo_object
= glyph
->object
;
6519 help_echo_pos
= glyph
->charpos
;
6522 /* Change the mouse pointer according to what is under X/Y. */
6523 map
= Fget_text_property (make_number (glyph
->charpos
),
6524 Qlocal_map
, glyph
->object
);
6526 cursor
= f
->output_data
.x
->nontext_cursor
;
6529 map
= Fget_text_property (make_number (glyph
->charpos
),
6530 Qkeymap
, glyph
->object
);
6532 cursor
= f
->output_data
.x
->nontext_cursor
;
6537 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6541 /* Take proper action when the mouse has moved to position X, Y on
6542 frame F as regards highlighting characters that have mouse-face
6543 properties. Also de-highlighting chars where the mouse was before.
6544 X and Y can be negative or out of range. */
6547 note_mouse_highlight (f
, x
, y
)
6551 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6556 /* When a menu is active, don't highlight because this looks odd. */
6557 #ifdef USE_X_TOOLKIT
6558 if (popup_activated ())
6562 if (disable_mouse_highlight
6563 || !f
->glyphs_initialized_p
)
6566 dpyinfo
->mouse_face_mouse_x
= x
;
6567 dpyinfo
->mouse_face_mouse_y
= y
;
6568 dpyinfo
->mouse_face_mouse_frame
= f
;
6570 if (dpyinfo
->mouse_face_defer
)
6575 dpyinfo
->mouse_face_deferred_gc
= 1;
6579 /* Which window is that in? */
6580 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6582 /* If we were displaying active text in another window, clear that. */
6583 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6584 clear_mouse_face (dpyinfo
);
6586 /* Not on a window -> return. */
6587 if (!WINDOWP (window
))
6590 /* Convert to window-relative pixel coordinates. */
6591 w
= XWINDOW (window
);
6592 frame_to_window_pixel_xy (w
, &x
, &y
);
6594 /* Handle tool-bar window differently since it doesn't display a
6596 if (EQ (window
, f
->tool_bar_window
))
6598 note_tool_bar_highlight (f
, x
, y
);
6602 if (portion
== 1 || portion
== 3)
6604 /* Mouse is on the mode or top line. */
6605 note_mode_line_highlight (w
, x
, portion
== 1);
6609 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6610 f
->output_data
.x
->text_cursor
);
6612 /* Are we in a window whose display is up to date?
6613 And verify the buffer's text has not changed. */
6614 if (/* Within text portion of the window. */
6616 && EQ (w
->window_end_valid
, w
->buffer
)
6617 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
6618 && (XFASTINT (w
->last_overlay_modified
)
6619 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
6621 int hpos
, vpos
, pos
, i
, area
;
6622 struct glyph
*glyph
;
6624 /* Find the glyph under X/Y. */
6625 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
);
6627 /* Clear mouse face if X/Y not over text. */
6629 || area
!= TEXT_AREA
6630 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6632 clear_mouse_face (dpyinfo
);
6636 pos
= glyph
->charpos
;
6637 xassert (w
->pseudo_window_p
|| BUFFERP (glyph
->object
));
6639 /* Check for mouse-face and help-echo. */
6641 Lisp_Object mouse_face
, overlay
, position
;
6642 Lisp_Object
*overlay_vec
;
6644 struct buffer
*obuf
;
6647 /* If we get an out-of-range value, return now; avoid an error. */
6648 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
6651 /* Make the window's buffer temporarily current for
6652 overlays_at and compute_char_face. */
6653 obuf
= current_buffer
;
6654 current_buffer
= XBUFFER (w
->buffer
);
6660 /* Is this char mouse-active or does it have help-echo? */
6661 XSETINT (position
, pos
);
6663 /* Put all the overlays we want in a vector in overlay_vec.
6664 Store the length in len. If there are more than 10, make
6665 enough space for all, and try again. */
6667 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6668 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
6669 if (noverlays
> len
)
6672 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6673 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
,0);
6676 /* Sort overlays into increasing priority order. */
6677 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6679 /* Check mouse-face highlighting. */
6680 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
6681 && vpos
>= dpyinfo
->mouse_face_beg_row
6682 && vpos
<= dpyinfo
->mouse_face_end_row
6683 && (vpos
> dpyinfo
->mouse_face_beg_row
6684 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6685 && (vpos
< dpyinfo
->mouse_face_end_row
6686 || hpos
< dpyinfo
->mouse_face_end_col
6687 || dpyinfo
->mouse_face_past_end
)))
6689 /* Clear the display of the old active region, if any. */
6690 clear_mouse_face (dpyinfo
);
6692 /* Find the highest priority overlay that has a mouse-face prop. */
6694 for (i
= noverlays
- 1; i
>= 0; --i
)
6696 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
6697 if (!NILP (mouse_face
))
6699 overlay
= overlay_vec
[i
];
6704 /* If no overlay applies, get a text property. */
6706 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
6708 /* Handle the overlay case. */
6709 if (! NILP (overlay
))
6711 /* Find the range of text around this char that
6712 should be active. */
6713 Lisp_Object before
, after
;
6716 before
= Foverlay_start (overlay
);
6717 after
= Foverlay_end (overlay
);
6718 /* Record this as the current active region. */
6719 fast_find_position (w
, XFASTINT (before
),
6720 &dpyinfo
->mouse_face_beg_col
,
6721 &dpyinfo
->mouse_face_beg_row
,
6722 &dpyinfo
->mouse_face_beg_x
,
6723 &dpyinfo
->mouse_face_beg_y
);
6724 dpyinfo
->mouse_face_past_end
6725 = !fast_find_position (w
, XFASTINT (after
),
6726 &dpyinfo
->mouse_face_end_col
,
6727 &dpyinfo
->mouse_face_end_row
,
6728 &dpyinfo
->mouse_face_end_x
,
6729 &dpyinfo
->mouse_face_end_y
);
6730 dpyinfo
->mouse_face_window
= window
;
6731 dpyinfo
->mouse_face_face_id
6732 = face_at_buffer_position (w
, pos
, 0, 0,
6733 &ignore
, pos
+ 1, 1);
6735 /* Display it as active. */
6736 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6738 /* Handle the text property case. */
6739 else if (! NILP (mouse_face
))
6741 /* Find the range of text around this char that
6742 should be active. */
6743 Lisp_Object before
, after
, beginning
, end
;
6746 beginning
= Fmarker_position (w
->start
);
6747 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
6748 - XFASTINT (w
->window_end_pos
)));
6750 = Fprevious_single_property_change (make_number (pos
+ 1),
6752 w
->buffer
, beginning
);
6754 = Fnext_single_property_change (position
, Qmouse_face
,
6756 /* Record this as the current active region. */
6757 fast_find_position (w
, XFASTINT (before
),
6758 &dpyinfo
->mouse_face_beg_col
,
6759 &dpyinfo
->mouse_face_beg_row
,
6760 &dpyinfo
->mouse_face_beg_x
,
6761 &dpyinfo
->mouse_face_beg_y
);
6762 dpyinfo
->mouse_face_past_end
6763 = !fast_find_position (w
, XFASTINT (after
),
6764 &dpyinfo
->mouse_face_end_col
,
6765 &dpyinfo
->mouse_face_end_row
,
6766 &dpyinfo
->mouse_face_end_x
,
6767 &dpyinfo
->mouse_face_end_y
);
6768 dpyinfo
->mouse_face_window
= window
;
6769 dpyinfo
->mouse_face_face_id
6770 = face_at_buffer_position (w
, pos
, 0, 0,
6771 &ignore
, pos
+ 1, 1);
6773 /* Display it as active. */
6774 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6778 /* Look for a `help-echo' property. */
6780 Lisp_Object help
, overlay
;
6782 /* Check overlays first. */
6783 help
= overlay
= Qnil
;
6784 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
6786 overlay
= overlay_vec
[i
];
6787 help
= Foverlay_get (overlay
, Qhelp_echo
);
6793 help_echo_window
= window
;
6794 help_echo_object
= overlay
;
6795 help_echo_pos
= pos
;
6799 /* Try text properties. */
6800 if ((STRINGP (glyph
->object
)
6801 && glyph
->charpos
>= 0
6802 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6803 || (BUFFERP (glyph
->object
)
6804 && glyph
->charpos
>= BEGV
6805 && glyph
->charpos
< ZV
))
6806 help
= Fget_text_property (make_number (glyph
->charpos
),
6807 Qhelp_echo
, glyph
->object
);
6812 help_echo_window
= window
;
6813 help_echo_object
= glyph
->object
;
6814 help_echo_pos
= glyph
->charpos
;
6821 current_buffer
= obuf
;
6827 redo_mouse_highlight ()
6829 if (!NILP (last_mouse_motion_frame
)
6830 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
6831 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
6832 last_mouse_motion_event
.x
,
6833 last_mouse_motion_event
.y
);
6838 /***********************************************************************
6840 ***********************************************************************/
6842 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
6843 struct glyph
**, int *, int *, int *));
6845 /* Tool-bar item index of the item on which a mouse button was pressed
6848 static int last_tool_bar_item
;
6851 /* Get information about the tool-bar item at position X/Y on frame F.
6852 Return in *GLYPH a pointer to the glyph of the tool-bar item in
6853 the current matrix of the tool-bar window of F, or NULL if not
6854 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
6855 item in F->current_tool_bar_items. Value is
6857 -1 if X/Y is not on a tool-bar item
6858 0 if X/Y is on the same item that was highlighted before.
6862 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
6865 struct glyph
**glyph
;
6866 int *hpos
, *vpos
, *prop_idx
;
6868 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6869 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6872 /* Find the glyph under X/Y. */
6873 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
);
6877 /* Get the start of this tool-bar item's properties in
6878 f->current_tool_bar_items. */
6879 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
6882 /* Is mouse on the highlighted item? */
6883 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
6884 && *vpos
>= dpyinfo
->mouse_face_beg_row
6885 && *vpos
<= dpyinfo
->mouse_face_end_row
6886 && (*vpos
> dpyinfo
->mouse_face_beg_row
6887 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
6888 && (*vpos
< dpyinfo
->mouse_face_end_row
6889 || *hpos
< dpyinfo
->mouse_face_end_col
6890 || dpyinfo
->mouse_face_past_end
))
6897 /* Handle mouse button event on the tool-bar of frame F, at
6898 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
6902 x_handle_tool_bar_click (f
, button_event
)
6904 XButtonEvent
*button_event
;
6906 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6907 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6908 int hpos
, vpos
, prop_idx
;
6909 struct glyph
*glyph
;
6910 Lisp_Object enabled_p
;
6911 int x
= button_event
->x
;
6912 int y
= button_event
->y
;
6914 /* If not on the highlighted tool-bar item, return. */
6915 frame_to_window_pixel_xy (w
, &x
, &y
);
6916 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
6919 /* If item is disabled, do nothing. */
6920 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
6921 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
6922 if (NILP (enabled_p
))
6925 if (button_event
->type
== ButtonPress
)
6927 /* Show item in pressed state. */
6928 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
6929 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
6930 last_tool_bar_item
= prop_idx
;
6934 Lisp_Object key
, frame
;
6935 struct input_event event
;
6937 /* Show item in released state. */
6938 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
6939 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
6941 key
= (XVECTOR (f
->current_tool_bar_items
)
6942 ->contents
[prop_idx
+ TOOL_BAR_ITEM_KEY
]);
6944 XSETFRAME (frame
, f
);
6945 event
.kind
= TOOL_BAR_EVENT
;
6946 event
.frame_or_window
= frame
;
6948 kbd_buffer_store_event (&event
);
6950 event
.kind
= TOOL_BAR_EVENT
;
6951 event
.frame_or_window
= frame
;
6953 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6954 button_event
->state
);
6955 kbd_buffer_store_event (&event
);
6956 last_tool_bar_item
= -1;
6961 /* Possibly highlight a tool-bar item on frame F when mouse moves to
6962 tool-bar window-relative coordinates X/Y. Called from
6963 note_mouse_highlight. */
6966 note_tool_bar_highlight (f
, x
, y
)
6970 Lisp_Object window
= f
->tool_bar_window
;
6971 struct window
*w
= XWINDOW (window
);
6972 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6974 struct glyph
*glyph
;
6975 struct glyph_row
*row
;
6977 Lisp_Object enabled_p
;
6979 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
6980 int mouse_down_p
, rc
;
6982 /* Function note_mouse_highlight is called with negative x(y
6983 values when mouse moves outside of the frame. */
6984 if (x
<= 0 || y
<= 0)
6986 clear_mouse_face (dpyinfo
);
6990 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
6993 /* Not on tool-bar item. */
6994 clear_mouse_face (dpyinfo
);
6998 /* On same tool-bar item as before. */
7001 clear_mouse_face (dpyinfo
);
7003 /* Mouse is down, but on different tool-bar item? */
7004 mouse_down_p
= (dpyinfo
->grabbed
7005 && f
== last_mouse_frame
7006 && FRAME_LIVE_P (f
));
7008 && last_tool_bar_item
!= prop_idx
)
7011 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
7012 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
7014 /* If tool-bar item is not enabled, don't highlight it. */
7015 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
7016 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
7017 if (!NILP (enabled_p
))
7019 /* Compute the x-position of the glyph. In front and past the
7020 image is a space. We include this is the highlighted area. */
7021 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
7022 for (i
= x
= 0; i
< hpos
; ++i
)
7023 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
7025 /* Record this as the current active region. */
7026 dpyinfo
->mouse_face_beg_col
= hpos
;
7027 dpyinfo
->mouse_face_beg_row
= vpos
;
7028 dpyinfo
->mouse_face_beg_x
= x
;
7029 dpyinfo
->mouse_face_beg_y
= row
->y
;
7030 dpyinfo
->mouse_face_past_end
= 0;
7032 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
7033 dpyinfo
->mouse_face_end_row
= vpos
;
7034 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
7035 dpyinfo
->mouse_face_end_y
= row
->y
;
7036 dpyinfo
->mouse_face_window
= window
;
7037 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
7039 /* Display it as active. */
7040 show_mouse_face (dpyinfo
, draw
);
7041 dpyinfo
->mouse_face_image_state
= draw
;
7046 /* Set help_echo to a help string.to display for this tool-bar item.
7047 XTread_socket does the rest. */
7048 help_echo_object
= help_echo_window
= Qnil
;
7050 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
7051 ->contents
[prop_idx
+ TOOL_BAR_ITEM_HELP
]);
7052 if (NILP (help_echo
))
7053 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
7054 ->contents
[prop_idx
+ TOOL_BAR_ITEM_CAPTION
]);
7059 /* Find the glyph matrix position of buffer position POS in window W.
7060 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7061 current glyphs must be up to date. If POS is above window start
7062 return (0, 0, 0, 0). If POS is after end of W, return end of
7066 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
)
7069 int *hpos
, *vpos
, *x
, *y
;
7073 int maybe_next_line_p
= 0;
7074 int line_start_position
;
7075 int yb
= window_text_bottom_y (w
);
7076 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
7077 struct glyph_row
*best_row
= row
;
7078 int row_vpos
= 0, best_row_vpos
= 0;
7083 if (row
->used
[TEXT_AREA
])
7084 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
7086 line_start_position
= 0;
7088 if (line_start_position
> pos
)
7090 /* If the position sought is the end of the buffer,
7091 don't include the blank lines at the bottom of the window. */
7092 else if (line_start_position
== pos
7093 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
7095 maybe_next_line_p
= 1;
7098 else if (line_start_position
> 0)
7101 best_row_vpos
= row_vpos
;
7104 if (row
->y
+ row
->height
>= yb
)
7111 /* Find the right column within BEST_ROW. */
7113 current_x
= best_row
->x
;
7114 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
7116 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
7119 charpos
= glyph
->charpos
;
7123 *vpos
= best_row_vpos
;
7128 else if (charpos
> pos
)
7130 else if (charpos
> 0)
7133 current_x
+= glyph
->pixel_width
;
7136 /* If we're looking for the end of the buffer,
7137 and we didn't find it in the line we scanned,
7138 use the start of the following line. */
7139 if (maybe_next_line_p
)
7144 current_x
= best_row
->x
;
7147 *vpos
= best_row_vpos
;
7148 *hpos
= lastcol
+ 1;
7155 /* Display the active region described by mouse_face_*
7156 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7159 show_mouse_face (dpyinfo
, draw
)
7160 struct x_display_info
*dpyinfo
;
7161 enum draw_glyphs_face draw
;
7163 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
7164 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7166 int cursor_off_p
= 0;
7167 struct cursor_pos saved_cursor
;
7169 saved_cursor
= output_cursor
;
7171 /* If window is in the process of being destroyed, don't bother
7173 if (w
->current_matrix
== NULL
)
7176 /* Recognize when we are called to operate on rows that don't exist
7177 anymore. This can happen when a window is split. */
7178 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
7181 set_output_cursor (&w
->phys_cursor
);
7183 /* Note that mouse_face_beg_row etc. are window relative. */
7184 for (i
= dpyinfo
->mouse_face_beg_row
;
7185 i
<= dpyinfo
->mouse_face_end_row
;
7188 int start_hpos
, end_hpos
, start_x
;
7189 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
7191 /* Don't do anything if row doesn't have valid contents. */
7192 if (!row
->enabled_p
)
7195 /* For all but the first row, the highlight starts at column 0. */
7196 if (i
== dpyinfo
->mouse_face_beg_row
)
7198 start_hpos
= dpyinfo
->mouse_face_beg_col
;
7199 start_x
= dpyinfo
->mouse_face_beg_x
;
7207 if (i
== dpyinfo
->mouse_face_end_row
)
7208 end_hpos
= dpyinfo
->mouse_face_end_col
;
7210 end_hpos
= row
->used
[TEXT_AREA
];
7212 /* If the cursor's in the text we are about to rewrite, turn the
7214 if (!w
->pseudo_window_p
7215 && i
== output_cursor
.vpos
7216 && output_cursor
.hpos
>= start_hpos
- 1
7217 && output_cursor
.hpos
<= end_hpos
)
7219 x_update_window_cursor (w
, 0);
7223 if (end_hpos
> start_hpos
)
7225 row
->mouse_face_p
= draw
== DRAW_MOUSE_FACE
;
7226 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
7227 start_hpos
, end_hpos
, draw
, NULL
, NULL
, 0);
7231 /* If we turned the cursor off, turn it back on. */
7233 x_display_cursor (w
, 1,
7234 output_cursor
.hpos
, output_cursor
.vpos
,
7235 output_cursor
.x
, output_cursor
.y
);
7237 output_cursor
= saved_cursor
;
7241 /* Change the mouse cursor. */
7242 if (draw
== DRAW_NORMAL_TEXT
)
7243 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7244 f
->output_data
.x
->text_cursor
);
7245 else if (draw
== DRAW_MOUSE_FACE
)
7246 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7247 f
->output_data
.x
->cross_cursor
);
7249 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7250 f
->output_data
.x
->nontext_cursor
);
7253 /* Clear out the mouse-highlighted active region.
7254 Redraw it un-highlighted first. */
7257 clear_mouse_face (dpyinfo
)
7258 struct x_display_info
*dpyinfo
;
7263 if (! NILP (dpyinfo
->mouse_face_window
))
7264 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7266 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7267 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7268 dpyinfo
->mouse_face_window
= Qnil
;
7272 /* Clear any mouse-face on window W. This function is part of the
7273 redisplay interface, and is called from try_window_id and similar
7274 functions to ensure the mouse-highlight is off. */
7277 x_clear_mouse_face (w
)
7280 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
7284 XSETWINDOW (window
, w
);
7285 if (EQ (window
, dpyinfo
->mouse_face_window
))
7286 clear_mouse_face (dpyinfo
);
7291 /* Just discard the mouse face information for frame F, if any.
7292 This is used when the size of F is changed. */
7295 cancel_mouse_face (f
)
7299 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7301 window
= dpyinfo
->mouse_face_window
;
7302 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7304 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7305 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7306 dpyinfo
->mouse_face_window
= Qnil
;
7310 static struct scroll_bar
*x_window_to_scroll_bar ();
7311 static void x_scroll_bar_report_motion ();
7313 /* Return the current position of the mouse.
7314 *fp should be a frame which indicates which display to ask about.
7316 If the mouse movement started in a scroll bar, set *fp, *bar_window,
7317 and *part to the frame, window, and scroll bar part that the mouse
7318 is over. Set *x and *y to the portion and whole of the mouse's
7319 position on the scroll bar.
7321 If the mouse movement started elsewhere, set *fp to the frame the
7322 mouse is on, *bar_window to nil, and *x and *y to the character cell
7325 Set *time to the server time-stamp for the time at which the mouse
7326 was at this position.
7328 Don't store anything if we don't have a valid set of values to report.
7330 This clears the mouse_moved flag, so we can wait for the next mouse
7334 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7337 Lisp_Object
*bar_window
;
7338 enum scroll_bar_part
*part
;
7340 unsigned long *time
;
7346 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7347 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7353 Window dummy_window
;
7356 Lisp_Object frame
, tail
;
7358 /* Clear the mouse-moved flag for every frame on this display. */
7359 FOR_EACH_FRAME (tail
, frame
)
7360 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
7361 XFRAME (frame
)->mouse_moved
= 0;
7363 last_mouse_scroll_bar
= Qnil
;
7365 /* Figure out which root window we're on. */
7366 XQueryPointer (FRAME_X_DISPLAY (*fp
),
7367 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
7369 /* The root window which contains the pointer. */
7372 /* Trash which we can't trust if the pointer is on
7373 a different screen. */
7376 /* The position on that root window. */
7379 /* More trash we can't trust. */
7382 /* Modifier keys and pointer buttons, about which
7384 (unsigned int *) &dummy
);
7386 /* Now we have a position on the root; find the innermost window
7387 containing the pointer. */
7391 int parent_x
= 0, parent_y
= 0;
7396 /* XTranslateCoordinates can get errors if the window
7397 structure is changing at the same time this function
7398 is running. So at least we must not crash from them. */
7400 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
7402 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
7403 && FRAME_LIVE_P (last_mouse_frame
))
7405 /* If mouse was grabbed on a frame, give coords for that frame
7406 even if the mouse is now outside it. */
7407 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7409 /* From-window, to-window. */
7410 root
, FRAME_X_WINDOW (last_mouse_frame
),
7412 /* From-position, to-position. */
7413 root_x
, root_y
, &win_x
, &win_y
,
7417 f1
= last_mouse_frame
;
7423 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7425 /* From-window, to-window. */
7428 /* From-position, to-position. */
7429 root_x
, root_y
, &win_x
, &win_y
,
7434 if (child
== None
|| child
== win
)
7442 /* Now we know that:
7443 win is the innermost window containing the pointer
7444 (XTC says it has no child containing the pointer),
7445 win_x and win_y are the pointer's position in it
7446 (XTC did this the last time through), and
7447 parent_x and parent_y are the pointer's position in win's parent.
7448 (They are what win_x and win_y were when win was child.
7449 If win is the root window, it has no parent, and
7450 parent_{x,y} are invalid, but that's okay, because we'll
7451 never use them in that case.) */
7453 /* Is win one of our frames? */
7454 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
7457 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
7460 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
7462 /* If not, is it one of our scroll bars? */
7465 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
7469 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7475 if (f1
== 0 && insist
> 0)
7476 f1
= SELECTED_FRAME ();
7480 /* Ok, we found a frame. Store all the values.
7481 last_mouse_glyph is a rectangle used to reduce the
7482 generation of mouse events. To not miss any motion
7483 events, we must divide the frame into rectangles of the
7484 size of the smallest character that could be displayed
7485 on it, i.e. into the same rectangles that matrices on
7486 the frame are divided into. */
7488 #if OLD_REDISPLAY_CODE
7489 int ignore1
, ignore2
;
7490 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
7492 FRAME_X_DISPLAY_INFO (f1
)->grabbed
7496 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
7497 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
7501 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7502 round down even for negative values. */
7508 last_mouse_glyph
.width
= width
;
7509 last_mouse_glyph
.height
= height
;
7510 last_mouse_glyph
.x
= (x
+ width
- 1) / width
* width
;
7511 last_mouse_glyph
.y
= (y
+ height
- 1) / height
* height
;
7518 XSETINT (*x
, win_x
);
7519 XSETINT (*y
, win_y
);
7520 *time
= last_mouse_movement_time
;
7529 #ifdef USE_X_TOOLKIT
7531 /* Atimer callback function for TIMER. Called every 0.1s to process
7532 Xt timeouts, if needed. We must avoid calling XtAppPending as
7533 much as possible because that function does an implicit XFlush
7534 that slows us down. */
7537 x_process_timeouts (timer
)
7538 struct atimer
*timer
;
7540 if (toolkit_scroll_bar_interaction
|| popup_activated_flag
)
7543 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
7544 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
7549 #endif /* USE_X_TOOLKIT */
7552 /* Scroll bar support. */
7554 /* Given an X window ID, find the struct scroll_bar which manages it.
7555 This can be called in GC, so we have to make sure to strip off mark
7558 static struct scroll_bar
*
7559 x_window_to_scroll_bar (window_id
)
7564 for (tail
= Vframe_list
;
7565 XGCTYPE (tail
) == Lisp_Cons
;
7568 Lisp_Object frame
, bar
, condemned
;
7570 frame
= XCAR (tail
);
7571 /* All elements of Vframe_list should be frames. */
7572 if (! GC_FRAMEP (frame
))
7575 /* Scan this frame's scroll bar list for a scroll bar with the
7577 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
7578 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
7579 /* This trick allows us to search both the ordinary and
7580 condemned scroll bar lists with one loop. */
7581 ! GC_NILP (bar
) || (bar
= condemned
,
7584 bar
= XSCROLL_BAR (bar
)->next
)
7585 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
7586 return XSCROLL_BAR (bar
);
7594 /************************************************************************
7596 ************************************************************************/
7598 #if USE_TOOLKIT_SCROLL_BARS
7600 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
7601 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
7602 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
7603 struct scroll_bar
*));
7604 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
7608 /* Id of action hook installed for scroll bars. */
7610 static XtActionHookId action_hook_id
;
7612 /* Lisp window being scrolled. Set when starting to interact with
7613 a toolkit scroll bar, reset to nil when ending the interaction. */
7615 static Lisp_Object window_being_scrolled
;
7617 /* Last scroll bar part sent in xm_scroll_callback. */
7619 static int last_scroll_bar_part
;
7621 /* Whether this is an Xaw with arrow-scrollbars. This should imply
7622 that movements of 1/20 of the screen size are mapped to up/down. */
7624 static Boolean xaw3d_arrow_scroll
;
7626 /* Whether the drag scrolling maintains the mouse at the top of the
7627 thumb. If not, resizing the thumb needs to be done more carefully
7628 to avoid jerkyness. */
7630 static Boolean xaw3d_pick_top
;
7633 /* Action hook installed via XtAppAddActionHook when toolkit scroll
7634 bars are used.. The hook is responsible for detecting when
7635 the user ends an interaction with the scroll bar, and generates
7636 a `end-scroll' scroll_bar_click' event if so. */
7639 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
7642 XtPointer client_data
;
7646 Cardinal
*num_params
;
7652 scroll_bar_p
= XmIsScrollBar (widget
);
7653 end_action
= "Release";
7654 #else /* !USE_MOTIF i.e. use Xaw */
7655 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
7656 end_action
= "EndScroll";
7657 #endif /* USE_MOTIF */
7660 && strcmp (action_name
, end_action
) == 0
7661 && WINDOWP (window_being_scrolled
))
7665 x_send_scroll_bar_event (window_being_scrolled
,
7666 scroll_bar_end_scroll
, 0, 0);
7667 w
= XWINDOW (window_being_scrolled
);
7668 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
7669 window_being_scrolled
= Qnil
;
7670 last_scroll_bar_part
= -1;
7672 /* Xt timeouts no longer needed. */
7673 toolkit_scroll_bar_interaction
= 0;
7678 /* Send a client message with message type Xatom_Scrollbar for a
7679 scroll action to the frame of WINDOW. PART is a value identifying
7680 the part of the scroll bar that was clicked on. PORTION is the
7681 amount to scroll of a whole of WHOLE. */
7684 x_send_scroll_bar_event (window
, part
, portion
, whole
)
7686 int part
, portion
, whole
;
7689 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
7690 struct frame
*f
= XFRAME (XWINDOW (window
)->frame
);
7692 /* Construct a ClientMessage event to send to the frame. */
7693 ev
->type
= ClientMessage
;
7694 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
7695 ev
->display
= FRAME_X_DISPLAY (f
);
7696 ev
->window
= FRAME_X_WINDOW (f
);
7698 ev
->data
.l
[0] = (long) XFASTINT (window
);
7699 ev
->data
.l
[1] = (long) part
;
7700 ev
->data
.l
[2] = (long) 0;
7701 ev
->data
.l
[3] = (long) portion
;
7702 ev
->data
.l
[4] = (long) whole
;
7704 /* Make Xt timeouts work while the scroll bar is active. */
7705 toolkit_scroll_bar_interaction
= 1;
7707 /* Setting the event mask to zero means that the message will
7708 be sent to the client that created the window, and if that
7709 window no longer exists, no event will be sent. */
7711 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
7716 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
7720 x_scroll_bar_to_input_event (event
, ievent
)
7722 struct input_event
*ievent
;
7724 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
7728 XSETFASTINT (window
, ev
->data
.l
[0]);
7729 f
= XFRAME (XWINDOW (window
)->frame
);
7731 ievent
->kind
= scroll_bar_click
;
7732 ievent
->frame_or_window
= window
;
7734 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
7735 ievent
->part
= ev
->data
.l
[1];
7736 ievent
->code
= ev
->data
.l
[2];
7737 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
7738 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
7739 ievent
->modifiers
= 0;
7745 /* Minimum and maximum values used for Motif scroll bars. */
7748 #define XM_SB_MAX 10000000
7749 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
7752 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
7753 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
7754 CALL_DATA is a pointer a a XmScrollBarCallbackStruct. */
7757 xm_scroll_callback (widget
, client_data
, call_data
)
7759 XtPointer client_data
, call_data
;
7761 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7762 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
7764 int part
= -1, whole
= 0, portion
= 0;
7768 case XmCR_DECREMENT
:
7769 bar
->dragging
= Qnil
;
7770 part
= scroll_bar_up_arrow
;
7773 case XmCR_INCREMENT
:
7774 bar
->dragging
= Qnil
;
7775 part
= scroll_bar_down_arrow
;
7778 case XmCR_PAGE_DECREMENT
:
7779 bar
->dragging
= Qnil
;
7780 part
= scroll_bar_above_handle
;
7783 case XmCR_PAGE_INCREMENT
:
7784 bar
->dragging
= Qnil
;
7785 part
= scroll_bar_below_handle
;
7789 bar
->dragging
= Qnil
;
7790 part
= scroll_bar_to_top
;
7793 case XmCR_TO_BOTTOM
:
7794 bar
->dragging
= Qnil
;
7795 part
= scroll_bar_to_bottom
;
7801 int dragging_down_p
= (INTEGERP (bar
->dragging
)
7802 && XINT (bar
->dragging
) <= cs
->value
);
7804 /* Get the slider size. */
7806 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
7809 /* At the max position of the scroll bar, do a line-wise
7810 movement. Without doing anything, the LessTif scroll bar
7811 calls us with the same cs->value again and again. If we
7812 want to make sure that we can reach the end of the buffer,
7813 we have to do something.
7815 Implementation note: setting bar->dragging always to
7816 cs->value gives a smoother movement at the max position.
7817 Setting it to nil when doing line-wise movement gives
7818 a better slider behavior. */
7820 if (cs
->value
+ slider_size
== XM_SB_MAX
7822 && last_scroll_bar_part
== scroll_bar_down_arrow
))
7824 part
= scroll_bar_down_arrow
;
7825 bar
->dragging
= Qnil
;
7829 whole
= XM_SB_RANGE
;
7830 portion
= min (cs
->value
- XM_SB_MIN
, XM_SB_MAX
- slider_size
);
7831 part
= scroll_bar_handle
;
7832 bar
->dragging
= make_number (cs
->value
);
7837 case XmCR_VALUE_CHANGED
:
7843 window_being_scrolled
= bar
->window
;
7844 last_scroll_bar_part
= part
;
7845 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
7850 #else /* !USE_MOTIF, i.e. Xaw. */
7853 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
7854 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
7855 scroll bar struct. CALL_DATA is a pointer to a float saying where
7859 xaw_jump_callback (widget
, client_data
, call_data
)
7861 XtPointer client_data
, call_data
;
7863 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7864 float top
= *(float *) call_data
;
7866 int whole
, portion
, height
;
7869 /* Get the size of the thumb, a value between 0 and 1. */
7871 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
7875 portion
= shown
< 1 ? top
* whole
: 0;
7877 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
7878 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
7879 the bottom, so we force the scrolling whenever we see that we're
7880 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
7881 we try to ensure that we always stay two pixels away from the
7883 part
= scroll_bar_down_arrow
;
7885 part
= scroll_bar_handle
;
7887 window_being_scrolled
= bar
->window
;
7888 bar
->dragging
= make_number (portion
);
7889 last_scroll_bar_part
= part
;
7890 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
7894 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
7895 i.e. line or page up or down. WIDGET is the Xaw scroll bar
7896 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
7897 the scroll bar. CALL_DATA is an integer specifying the action that
7898 has taken place. It's magnitude is in the range 0..height of the
7899 scroll bar. Negative values mean scroll towards buffer start.
7900 Values < height of scroll bar mean line-wise movement. */
7903 xaw_scroll_callback (widget
, client_data
, call_data
)
7905 XtPointer client_data
, call_data
;
7907 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7908 int position
= (int) call_data
;
7912 /* Get the height of the scroll bar. */
7914 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
7917 if (abs (position
) >= height
)
7918 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
7920 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
7921 it maps line-movement to call_data = max(5, height/20). */
7922 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
7923 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
7925 part
= scroll_bar_move_ratio
;
7927 window_being_scrolled
= bar
->window
;
7928 bar
->dragging
= Qnil
;
7929 last_scroll_bar_part
= part
;
7930 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
7934 #endif /* not USE_MOTIF */
7937 /* Create the widget for scroll bar BAR on frame F. Record the widget
7938 and X window of the scroll bar in BAR. */
7941 x_create_toolkit_scroll_bar (f
, bar
)
7943 struct scroll_bar
*bar
;
7949 char *scroll_bar_name
= "verticalScrollBar";
7950 unsigned long pixel
;
7955 /* LessTif 0.85, problems:
7957 1. When the mouse if over the scroll bar, the scroll bar will
7958 get keyboard events. I didn't find a way to turn this off.
7960 2. Do we have to explicitly set the cursor to get an arrow
7961 cursor (see below)? */
7963 /* Set resources. Create the widget. */
7964 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
7965 XtSetArg (av
[ac
], XmNminimum
, XM_SB_MIN
); ++ac
;
7966 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
7967 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
7968 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
7969 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
7970 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
7972 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
7975 XtSetArg (av
[ac
], XmNforeground
, pixel
);
7979 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
7982 XtSetArg (av
[ac
], XmNbackground
, pixel
);
7986 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
7987 scroll_bar_name
, av
, ac
);
7989 /* Add one callback for everything that can happen. */
7990 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
7992 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
7994 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
7996 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
7998 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
8000 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
8002 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
8005 /* Realize the widget. Only after that is the X window created. */
8006 XtRealizeWidget (widget
);
8008 /* Set the cursor to an arrow. I didn't find a resource to do that.
8009 And I'm wondering why it hasn't an arrow cursor by default. */
8010 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
8011 f
->output_data
.x
->nontext_cursor
);
8013 #else /* !USE_MOTIF i.e. use Xaw */
8015 /* Set resources. Create the widget. The background of the
8016 Xaw3d scroll bar widget is a little bit light for my taste.
8017 We don't alter it here to let users change it according
8018 to their taste with `emacs*verticalScrollBar.background: xxx'. */
8019 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8020 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
8021 /* For smoother scrolling with Xaw3d -sm */
8022 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
8023 /* XtSetArg (av[ac], XtNbeNiceToColormap, True); ++ac; */
8025 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8028 XtSetArg (av
[ac
], XtNforeground
, pixel
);
8032 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8035 XtSetArg (av
[ac
], XtNbackground
, pixel
);
8039 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
8040 f
->output_data
.x
->edit_widget
, av
, ac
);
8044 char *val
= initial
;
8045 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
8046 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
8048 { /* ARROW_SCROLL */
8049 xaw3d_arrow_scroll
= True
;
8050 /* Isn't that just a personal preference ? -sm */
8051 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
8055 /* Define callbacks. */
8056 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
8057 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
8060 /* Realize the widget. Only after that is the X window created. */
8061 XtRealizeWidget (widget
);
8063 #endif /* !USE_MOTIF */
8065 /* Install an action hook that let's us detect when the user
8066 finishes interacting with a scroll bar. */
8067 if (action_hook_id
== 0)
8068 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
8070 /* Remember X window and widget in the scroll bar vector. */
8071 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
8072 xwindow
= XtWindow (widget
);
8073 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
8079 /* Set the thumb size and position of scroll bar BAR. We are currently
8080 displaying PORTION out of a whole WHOLE, and our position POSITION. */
8083 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
8084 struct scroll_bar
*bar
;
8085 int portion
, position
, whole
;
8088 Widget widget
= SCROLL_BAR_X_WIDGET (bar
);
8094 top
= (float) position
/ whole
;
8095 shown
= (float) portion
/ whole
;
8103 Boolean arrow1_selected
, arrow2_selected
;
8104 unsigned char flags
;
8105 XmScrollBarWidget sb
;
8107 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
8108 is the scroll bar's maximum and MIN is the scroll bar's minimum
8110 size
= shown
* XM_SB_RANGE
;
8111 size
= min (size
, XM_SB_RANGE
);
8112 size
= max (size
, 1);
8114 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
8115 value
= top
* XM_SB_RANGE
;
8116 value
= min (value
, XM_SB_MAX
- size
);
8117 value
= max (value
, XM_SB_MIN
);
8119 /* LessTif: Calling XmScrollBarSetValues after an increment or
8120 decrement turns off auto-repeat LessTif-internally. This can
8121 be seen in ScrollBar.c which resets Arrow1Selected and
8122 Arrow2Selected. It also sets internal flags so that LessTif
8123 believes the mouse is in the slider. We either have to change
8124 our code, or work around that by accessing private data. */
8126 sb
= (XmScrollBarWidget
) widget
;
8127 arrow1_selected
= sb
->scrollBar
.arrow1_selected
;
8128 arrow2_selected
= sb
->scrollBar
.arrow2_selected
;
8129 flags
= sb
->scrollBar
.flags
;
8131 if (NILP (bar
->dragging
))
8132 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
8133 else if (last_scroll_bar_part
== scroll_bar_down_arrow
)
8134 /* This has the negative side effect that the slider value is
8135 not what it would be if we scrolled here using line-wise or
8136 page-wise movement. */
8137 XmScrollBarSetValues (widget
, value
, XM_SB_RANGE
- value
, 0, 0, False
);
8140 /* If currently dragging, only update the slider size.
8141 This reduces flicker effects. */
8142 int old_value
, old_size
, increment
, page_increment
;
8144 XmScrollBarGetValues (widget
, &old_value
, &old_size
,
8145 &increment
, &page_increment
);
8146 XmScrollBarSetValues (widget
, old_value
,
8147 min (size
, XM_SB_RANGE
- old_value
),
8151 sb
->scrollBar
.arrow1_selected
= arrow1_selected
;
8152 sb
->scrollBar
.arrow2_selected
= arrow2_selected
;
8153 sb
->scrollBar
.flags
= flags
;
8155 #else /* !USE_MOTIF i.e. use Xaw */
8157 float old_top
, old_shown
;
8159 XtVaGetValues (widget
,
8160 XtNtopOfThumb
, &old_top
,
8161 XtNshown
, &old_shown
,
8165 /* Massage the top+shown values. */
8166 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
8167 top
= max (0, min (1, top
));
8170 /* Keep two pixels available for moving the thumb down. */
8171 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
8173 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
8174 check that your system's configuration file contains a define
8175 for `NARROWPROTO'. See s/freebsd.h for an example. */
8176 if (top
!= old_top
|| shown
!= old_shown
)
8178 if (NILP (bar
->dragging
))
8179 XawScrollbarSetThumb (widget
, top
, shown
);
8183 ScrollbarWidget sb
= (ScrollbarWidget
) widget
;
8184 int scroll_mode
= 0;
8186 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
8187 if (xaw3d_arrow_scroll
)
8189 /* Xaw3d stupidly ignores resize requests while dragging
8190 so we have to make it believe it's not in dragging mode. */
8191 scroll_mode
= sb
->scrollbar
.scroll_mode
;
8192 if (scroll_mode
== 2)
8193 sb
->scrollbar
.scroll_mode
= 0;
8196 /* Try to make the scrolling a tad smoother. */
8197 if (!xaw3d_pick_top
)
8198 shown
= min (shown
, old_shown
);
8200 XawScrollbarSetThumb (widget
, top
, shown
);
8203 if (xaw3d_arrow_scroll
&& scroll_mode
== 2)
8204 sb
->scrollbar
.scroll_mode
= scroll_mode
;
8209 #endif /* !USE_MOTIF */
8214 #endif /* USE_TOOLKIT_SCROLL_BARS */
8218 /************************************************************************
8219 Scroll bars, general
8220 ************************************************************************/
8222 /* Create a scroll bar and return the scroll bar vector for it. W is
8223 the Emacs window on which to create the scroll bar. TOP, LEFT,
8224 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
8227 static struct scroll_bar
*
8228 x_scroll_bar_create (w
, top
, left
, width
, height
)
8230 int top
, left
, width
, height
;
8232 struct frame
*f
= XFRAME (w
->frame
);
8233 struct scroll_bar
*bar
8234 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
8238 #if USE_TOOLKIT_SCROLL_BARS
8239 x_create_toolkit_scroll_bar (f
, bar
);
8240 #else /* not USE_TOOLKIT_SCROLL_BARS */
8242 XSetWindowAttributes a
;
8246 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8247 if (a
.background_pixel
== -1)
8248 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
8250 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
8251 | ButtonMotionMask
| PointerMotionHintMask
8253 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
8255 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
8257 /* Clear the area of W that will serve as a scroll bar. This is
8258 for the case that a window has been split horizontally. In
8259 this case, no clear_frame is generated to reduce flickering. */
8260 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8262 window_box_height (w
), False
);
8264 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8265 /* Position and size of scroll bar. */
8266 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8268 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8270 /* Border width, depth, class, and visual. */
8277 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
8279 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8281 XSETWINDOW (bar
->window
, w
);
8282 XSETINT (bar
->top
, top
);
8283 XSETINT (bar
->left
, left
);
8284 XSETINT (bar
->width
, width
);
8285 XSETINT (bar
->height
, height
);
8286 XSETINT (bar
->start
, 0);
8287 XSETINT (bar
->end
, 0);
8288 bar
->dragging
= Qnil
;
8290 /* Add bar to its frame's list of scroll bars. */
8291 bar
->next
= FRAME_SCROLL_BARS (f
);
8293 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8294 if (!NILP (bar
->next
))
8295 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8297 /* Map the window/widget. */
8298 #if USE_TOOLKIT_SCROLL_BARS
8299 XtConfigureWidget (SCROLL_BAR_X_WIDGET (bar
),
8300 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8302 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8304 XtMapWidget (SCROLL_BAR_X_WIDGET (bar
));
8305 #else /* not USE_TOOLKIT_SCROLL_BARS */
8306 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
8307 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8314 /* Draw BAR's handle in the proper position.
8316 If the handle is already drawn from START to END, don't bother
8317 redrawing it, unless REBUILD is non-zero; in that case, always
8318 redraw it. (REBUILD is handy for drawing the handle after expose
8321 Normally, we want to constrain the start and end of the handle to
8322 fit inside its rectangle, but if the user is dragging the scroll
8323 bar handle, we want to let them drag it down all the way, so that
8324 the bar's top is as far down as it goes; otherwise, there's no way
8325 to move to the very end of the buffer. */
8327 #ifndef USE_TOOLKIT_SCROLL_BARS
8330 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
8331 struct scroll_bar
*bar
;
8335 int dragging
= ! NILP (bar
->dragging
);
8336 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8337 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8338 GC gc
= f
->output_data
.x
->normal_gc
;
8340 /* If the display is already accurate, do nothing. */
8342 && start
== XINT (bar
->start
)
8343 && end
== XINT (bar
->end
))
8349 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
8350 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8351 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8353 /* Make sure the values are reasonable, and try to preserve
8354 the distance between start and end. */
8356 int length
= end
- start
;
8360 else if (start
> top_range
)
8362 end
= start
+ length
;
8366 else if (end
> top_range
&& ! dragging
)
8370 /* Store the adjusted setting in the scroll bar. */
8371 XSETINT (bar
->start
, start
);
8372 XSETINT (bar
->end
, end
);
8374 /* Clip the end position, just for display. */
8375 if (end
> top_range
)
8378 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
8379 below top positions, to make sure the handle is always at least
8380 that many pixels tall. */
8381 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8383 /* Draw the empty space above the handle. Note that we can't clear
8384 zero-height areas; that means "clear to end of window." */
8386 XClearArea (FRAME_X_DISPLAY (f
), w
,
8388 /* x, y, width, height, and exposures. */
8389 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8390 VERTICAL_SCROLL_BAR_TOP_BORDER
,
8391 inside_width
, start
,
8394 /* Change to proper foreground color if one is specified. */
8395 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8396 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8397 f
->output_data
.x
->scroll_bar_foreground_pixel
);
8399 /* Draw the handle itself. */
8400 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8402 /* x, y, width, height */
8403 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8404 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
8405 inside_width
, end
- start
);
8407 /* Restore the foreground color of the GC if we changed it above. */
8408 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8409 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8410 f
->output_data
.x
->foreground_pixel
);
8412 /* Draw the empty space below the handle. Note that we can't
8413 clear zero-height areas; that means "clear to end of window." */
8414 if (end
< inside_height
)
8415 XClearArea (FRAME_X_DISPLAY (f
), w
,
8417 /* x, y, width, height, and exposures. */
8418 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8419 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
8420 inside_width
, inside_height
- end
,
8428 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8430 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
8434 x_scroll_bar_remove (bar
)
8435 struct scroll_bar
*bar
;
8439 #if USE_TOOLKIT_SCROLL_BARS
8440 XtDestroyWidget (SCROLL_BAR_X_WIDGET (bar
));
8441 #else /* not USE_TOOLKIT_SCROLL_BARS */
8443 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8444 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
8446 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8448 /* Disassociate this scroll bar from its window. */
8449 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
8455 /* Set the handle of the vertical scroll bar for WINDOW to indicate
8456 that we are displaying PORTION characters out of a total of WHOLE
8457 characters, starting at POSITION. If WINDOW has no scroll bar,
8461 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
8463 int portion
, whole
, position
;
8465 struct frame
*f
= XFRAME (w
->frame
);
8466 struct scroll_bar
*bar
;
8467 int top
, height
, left
, sb_left
, width
, sb_width
;
8468 int window_x
, window_y
, window_width
, window_height
;
8470 /* Get window dimensions. */
8471 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
8473 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
8474 height
= window_height
;
8476 /* Compute the left edge of the scroll bar area. */
8477 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8478 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
8480 left
= XFASTINT (w
->left
);
8481 left
*= CANON_X_UNIT (f
);
8482 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
8484 /* Compute the width of the scroll bar which might be less than
8485 the width of the area reserved for the scroll bar. */
8486 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
8487 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
8491 /* Compute the left edge of the scroll bar. */
8492 #ifdef USE_TOOLKIT_SCROLL_BARS
8493 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8494 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
8496 sb_left
= left
+ (width
- sb_width
) / 2;
8498 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8499 sb_left
= left
+ width
- sb_width
;
8504 /* Does the scroll bar exist yet? */
8505 if (NILP (w
->vertical_scroll_bar
))
8508 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8509 left
, top
, width
, height
, False
);
8511 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
8515 /* It may just need to be moved and resized. */
8516 unsigned int mask
= 0;
8518 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
8522 if (sb_left
!= XINT (bar
->left
))
8524 if (top
!= XINT (bar
->top
))
8526 if (sb_width
!= XINT (bar
->width
))
8528 if (height
!= XINT (bar
->height
))
8531 #ifdef USE_TOOLKIT_SCROLL_BARS
8533 /* Since toolkit scroll bars are smaller than the space reserved
8534 for them on the frame, we have to clear "under" them. */
8535 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8536 left
, top
, width
, height
, False
);
8538 /* Move/size the scroll bar widget. */
8540 XtConfigureWidget (SCROLL_BAR_X_WIDGET (bar
),
8541 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8543 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8546 #else /* not USE_TOOLKIT_SCROLL_BARS */
8548 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
8550 /* Clear areas not covered by the scroll bar. This makes sure a
8551 previous mode line display is cleared after C-x 2 C-x 1, for
8552 example. Non-toolkit scroll bars are as wide as the area
8553 reserved for scroll bars - trim at both sides. */
8554 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8555 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8557 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8558 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8559 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8563 /* Move/size the scroll bar window. */
8568 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
8570 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
8572 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
8576 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8578 /* Remember new settings. */
8579 XSETINT (bar
->left
, sb_left
);
8580 XSETINT (bar
->top
, top
);
8581 XSETINT (bar
->width
, sb_width
);
8582 XSETINT (bar
->height
, height
);
8587 #if USE_TOOLKIT_SCROLL_BARS
8588 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
8589 #else /* not USE_TOOLKIT_SCROLL_BARS */
8590 /* Set the scroll bar's current state, unless we're currently being
8592 if (NILP (bar
->dragging
))
8594 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
8597 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
8600 int start
= ((double) position
* top_range
) / whole
;
8601 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
8602 x_scroll_bar_set_handle (bar
, start
, end
, 0);
8605 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8607 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
8611 /* The following three hooks are used when we're doing a thorough
8612 redisplay of the frame. We don't explicitly know which scroll bars
8613 are going to be deleted, because keeping track of when windows go
8614 away is a real pain - "Can you say set-window-configuration, boys
8615 and girls?" Instead, we just assert at the beginning of redisplay
8616 that *all* scroll bars are to be removed, and then save a scroll bar
8617 from the fiery pit when we actually redisplay its window. */
8619 /* Arrange for all scroll bars on FRAME to be removed at the next call
8620 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
8621 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
8624 XTcondemn_scroll_bars (frame
)
8627 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
8628 while (! NILP (FRAME_SCROLL_BARS (frame
)))
8631 bar
= FRAME_SCROLL_BARS (frame
);
8632 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
8633 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
8634 XSCROLL_BAR (bar
)->prev
= Qnil
;
8635 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
8636 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
8637 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
8642 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
8643 Note that WINDOW isn't necessarily condemned at all. */
8646 XTredeem_scroll_bar (window
)
8647 struct window
*window
;
8649 struct scroll_bar
*bar
;
8652 /* We can't redeem this window's scroll bar if it doesn't have one. */
8653 if (NILP (window
->vertical_scroll_bar
))
8656 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
8658 /* Unlink it from the condemned list. */
8659 f
= XFRAME (WINDOW_FRAME (window
));
8660 if (NILP (bar
->prev
))
8662 /* If the prev pointer is nil, it must be the first in one of
8664 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
8665 /* It's not condemned. Everything's fine. */
8667 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
8668 window
->vertical_scroll_bar
))
8669 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
8671 /* If its prev pointer is nil, it must be at the front of
8672 one or the other! */
8676 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
8678 if (! NILP (bar
->next
))
8679 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
8681 bar
->next
= FRAME_SCROLL_BARS (f
);
8683 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8684 if (! NILP (bar
->next
))
8685 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8688 /* Remove all scroll bars on FRAME that haven't been saved since the
8689 last call to `*condemn_scroll_bars_hook'. */
8692 XTjudge_scroll_bars (f
)
8695 Lisp_Object bar
, next
;
8697 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
8699 /* Clear out the condemned list now so we won't try to process any
8700 more events on the hapless scroll bars. */
8701 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
8703 for (; ! NILP (bar
); bar
= next
)
8705 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
8707 x_scroll_bar_remove (b
);
8710 b
->next
= b
->prev
= Qnil
;
8713 /* Now there should be no references to the condemned scroll bars,
8714 and they should get garbage-collected. */
8718 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
8719 is a no-op when using toolkit scroll bars.
8721 This may be called from a signal handler, so we have to ignore GC
8725 x_scroll_bar_expose (bar
, event
)
8726 struct scroll_bar
*bar
;
8729 #ifndef USE_TOOLKIT_SCROLL_BARS
8731 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8732 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8733 GC gc
= f
->output_data
.x
->normal_gc
;
8734 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
8738 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
8740 /* Draw a one-pixel border just inside the edges of the scroll bar. */
8741 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8743 /* x, y, width, height */
8745 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
8746 XINT (bar
->height
) - 1);
8750 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8753 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
8754 is set to something other than no_event, it is enqueued.
8756 This may be called from a signal handler, so we have to ignore GC
8759 #ifndef USE_TOOLKIT_SCROLL_BARS
8762 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
8763 struct scroll_bar
*bar
;
8765 struct input_event
*emacs_event
;
8767 if (! GC_WINDOWP (bar
->window
))
8770 emacs_event
->kind
= scroll_bar_click
;
8771 emacs_event
->code
= event
->xbutton
.button
- Button1
;
8772 emacs_event
->modifiers
8773 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
8774 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
8775 event
->xbutton
.state
)
8776 | (event
->type
== ButtonRelease
8779 emacs_event
->frame_or_window
= bar
->window
;
8780 emacs_event
->arg
= Qnil
;
8781 emacs_event
->timestamp
= event
->xbutton
.time
;
8784 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8786 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8789 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8790 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
8793 if (y
> top_range
) y
= top_range
;
8795 if (y
< XINT (bar
->start
))
8796 emacs_event
->part
= scroll_bar_above_handle
;
8797 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
8798 emacs_event
->part
= scroll_bar_handle
;
8800 emacs_event
->part
= scroll_bar_below_handle
;
8802 /* Just because the user has clicked on the handle doesn't mean
8803 they want to drag it. Lisp code needs to be able to decide
8804 whether or not we're dragging. */
8806 /* If the user has just clicked on the handle, record where they're
8808 if (event
->type
== ButtonPress
8809 && emacs_event
->part
== scroll_bar_handle
)
8810 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
8813 /* If the user has released the handle, set it to its final position. */
8814 if (event
->type
== ButtonRelease
8815 && ! NILP (bar
->dragging
))
8817 int new_start
= y
- XINT (bar
->dragging
);
8818 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8820 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8821 bar
->dragging
= Qnil
;
8824 /* Same deal here as the other #if 0. */
8826 /* Clicks on the handle are always reported as occurring at the top of
8828 if (emacs_event
->part
== scroll_bar_handle
)
8829 emacs_event
->x
= bar
->start
;
8831 XSETINT (emacs_event
->x
, y
);
8833 XSETINT (emacs_event
->x
, y
);
8836 XSETINT (emacs_event
->y
, top_range
);
8840 /* Handle some mouse motion while someone is dragging the scroll bar.
8842 This may be called from a signal handler, so we have to ignore GC
8846 x_scroll_bar_note_movement (bar
, event
)
8847 struct scroll_bar
*bar
;
8850 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
8852 last_mouse_movement_time
= event
->xmotion
.time
;
8855 XSETVECTOR (last_mouse_scroll_bar
, bar
);
8857 /* If we're dragging the bar, display it. */
8858 if (! GC_NILP (bar
->dragging
))
8860 /* Where should the handle be now? */
8861 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
8863 if (new_start
!= XINT (bar
->start
))
8865 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8867 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8872 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8874 /* Return information to the user about the current position of the mouse
8875 on the scroll bar. */
8878 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
8880 Lisp_Object
*bar_window
;
8881 enum scroll_bar_part
*part
;
8883 unsigned long *time
;
8885 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
8886 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8887 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8889 Window dummy_window
;
8891 unsigned int dummy_mask
;
8895 /* Get the mouse's position relative to the scroll bar window, and
8897 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
8899 /* Root, child, root x and root y. */
8900 &dummy_window
, &dummy_window
,
8901 &dummy_coord
, &dummy_coord
,
8903 /* Position relative to scroll bar. */
8906 /* Mouse buttons and modifier keys. */
8913 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8916 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8918 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
8920 if (! NILP (bar
->dragging
))
8921 win_y
-= XINT (bar
->dragging
);
8925 if (win_y
> top_range
)
8929 *bar_window
= bar
->window
;
8931 if (! NILP (bar
->dragging
))
8932 *part
= scroll_bar_handle
;
8933 else if (win_y
< XINT (bar
->start
))
8934 *part
= scroll_bar_above_handle
;
8935 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
8936 *part
= scroll_bar_handle
;
8938 *part
= scroll_bar_below_handle
;
8940 XSETINT (*x
, win_y
);
8941 XSETINT (*y
, top_range
);
8944 last_mouse_scroll_bar
= Qnil
;
8947 *time
= last_mouse_movement_time
;
8953 /* The screen has been cleared so we may have changed foreground or
8954 background colors, and the scroll bars may need to be redrawn.
8955 Clear out the scroll bars, and ask for expose events, so we can
8959 x_scroll_bar_clear (f
)
8962 #ifndef USE_TOOLKIT_SCROLL_BARS
8965 /* We can have scroll bars even if this is 0,
8966 if we just turned off scroll bar mode.
8967 But in that case we should not clear them. */
8968 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8969 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
8970 bar
= XSCROLL_BAR (bar
)->next
)
8971 XClearArea (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
8973 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8976 /* This processes Expose events from the menu-bar specific X event
8977 loop in xmenu.c. This allows to redisplay the frame if necessary
8978 when handling menu-bar or pop-up items. */
8981 process_expose_from_menu (event
)
8985 struct x_display_info
*dpyinfo
;
8986 int frame_exposed_p
= 0;
8990 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
8991 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
8994 if (f
->async_visible
== 0)
8996 f
->async_visible
= 1;
8997 f
->async_iconified
= 0;
8998 f
->output_data
.x
->has_been_visible
= 1;
8999 SET_FRAME_GARBAGED (f
);
9003 expose_frame (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
9004 event
.xexpose
.x
, event
.xexpose
.y
,
9005 event
.xexpose
.width
, event
.xexpose
.height
);
9006 frame_exposed_p
= 1;
9011 struct scroll_bar
*bar
9012 = x_window_to_scroll_bar (event
.xexpose
.window
);
9015 x_scroll_bar_expose (bar
, &event
);
9019 return frame_exposed_p
;
9022 /* Define a queue to save up SelectionRequest events for later handling. */
9024 struct selection_event_queue
9027 struct selection_event_queue
*next
;
9030 static struct selection_event_queue
*queue
;
9032 /* Nonzero means queue up certain events--don't process them yet. */
9034 static int x_queue_selection_requests
;
9036 /* Queue up an X event *EVENT, to be processed later. */
9039 x_queue_event (f
, event
)
9043 struct selection_event_queue
*queue_tmp
9044 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
9046 if (queue_tmp
!= NULL
)
9048 queue_tmp
->event
= *event
;
9049 queue_tmp
->next
= queue
;
9054 /* Take all the queued events and put them back
9055 so that they get processed afresh. */
9058 x_unqueue_events (display
)
9061 while (queue
!= NULL
)
9063 struct selection_event_queue
*queue_tmp
= queue
;
9064 XPutBackEvent (display
, &queue_tmp
->event
);
9065 queue
= queue_tmp
->next
;
9066 xfree ((char *)queue_tmp
);
9070 /* Start queuing SelectionRequest events. */
9073 x_start_queuing_selection_requests (display
)
9076 x_queue_selection_requests
++;
9079 /* Stop queuing SelectionRequest events. */
9082 x_stop_queuing_selection_requests (display
)
9085 x_queue_selection_requests
--;
9086 x_unqueue_events (display
);
9089 /* The main X event-reading loop - XTread_socket. */
9091 /* Time stamp of enter window event. This is only used by XTread_socket,
9092 but we have to put it out here, since static variables within functions
9093 sometimes don't work. */
9095 static Time enter_timestamp
;
9097 /* This holds the state XLookupString needs to implement dead keys
9098 and other tricks known as "compose processing". _X Window System_
9099 says that a portable program can't use this, but Stephen Gildea assures
9100 me that letting the compiler initialize it to zeros will work okay.
9102 This must be defined outside of XTread_socket, for the same reasons
9103 given for enter_time stamp, above. */
9105 static XComposeStatus compose_status
;
9107 /* Record the last 100 characters stored
9108 to help debug the loss-of-chars-during-GC problem. */
9110 static int temp_index
;
9111 static short temp_buffer
[100];
9113 /* Set this to nonzero to fake an "X I/O error"
9114 on a particular display. */
9116 struct x_display_info
*XTread_socket_fake_io_error
;
9118 /* When we find no input here, we occasionally do a no-op command
9119 to verify that the X server is still running and we can still talk with it.
9120 We try all the open displays, one by one.
9121 This variable is used for cycling thru the displays. */
9123 static struct x_display_info
*next_noop_dpyinfo
;
9125 #define SET_SAVED_MENU_EVENT(size) \
9128 if (f->output_data.x->saved_menu_event == 0) \
9129 f->output_data.x->saved_menu_event \
9130 = (XEvent *) xmalloc (sizeof (XEvent)); \
9131 bcopy (&event, f->output_data.x->saved_menu_event, size); \
9132 if (numchars >= 1) \
9134 bufp->kind = menu_bar_activate_event; \
9135 XSETFRAME (bufp->frame_or_window, f); \
9144 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
9145 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
9147 /* Read events coming from the X server.
9148 This routine is called by the SIGIO handler.
9149 We return as soon as there are no more events to be read.
9151 Events representing keys are stored in buffer BUFP,
9152 which can hold up to NUMCHARS characters.
9153 We return the number of characters stored into the buffer,
9154 thus pretending to be `read'.
9156 EXPECTED is nonzero if the caller knows input is available. */
9159 XTread_socket (sd
, bufp
, numchars
, expected
)
9161 /* register */ struct input_event
*bufp
;
9162 /* register */ int numchars
;
9169 int event_found
= 0;
9170 struct x_display_info
*dpyinfo
;
9171 struct coding_system coding
;
9173 if (interrupt_input_blocked
)
9175 interrupt_input_pending
= 1;
9179 interrupt_input_pending
= 0;
9182 /* So people can tell when we have read the available input. */
9183 input_signal_count
++;
9186 abort (); /* Don't think this happens. */
9190 /* The input should be decoded if it is from XIM. Currently the
9191 locale of XIM is the same as that of the system. So, we can use
9192 Vlocale_coding_system which is initialized properly at Emacs
9194 setup_coding_system (Vlocale_coding_system
, &coding
);
9195 coding
.src_multibyte
= 0;
9196 coding
.dst_multibyte
= 1;
9197 /* The input is converted to events, thus we can't handle
9198 composition. Anyway, there's no XIM that gives us composition
9200 coding
.composing
= COMPOSITION_DISABLED
;
9202 /* Find the display we are supposed to read input for.
9203 It's the one communicating on descriptor SD. */
9204 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
9206 #if 0 /* This ought to be unnecessary; let's verify it. */
9208 /* If available, Xlib uses FIOSNBIO to make the socket
9209 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
9210 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
9211 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
9212 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
9213 #endif /* ! defined (FIOSNBIO) */
9216 #if 0 /* This code can't be made to work, with multiple displays,
9217 and appears not to be used on any system any more.
9218 Also keyboard.c doesn't turn O_NDELAY on and off
9219 for X connections. */
9222 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
9224 extern int read_alarm_should_throw
;
9225 read_alarm_should_throw
= 1;
9226 XPeekEvent (dpyinfo
->display
, &event
);
9227 read_alarm_should_throw
= 0;
9229 #endif /* HAVE_SELECT */
9233 /* For debugging, this gives a way to fake an I/O error. */
9234 if (dpyinfo
== XTread_socket_fake_io_error
)
9236 XTread_socket_fake_io_error
= 0;
9237 x_io_error_quitter (dpyinfo
->display
);
9240 while (XPending (dpyinfo
->display
))
9242 XNextEvent (dpyinfo
->display
, &event
);
9246 /* Filter events for the current X input method.
9247 XFilterEvent returns non-zero if the input method has
9248 consumed the event. We pass the frame's X window to
9249 XFilterEvent because that's the one for which the IC
9251 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
9252 event
.xclient
.window
);
9253 if (XFilterEvent (&event
, f1
? FRAME_X_WINDOW (f1
) : None
))
9263 if (event
.xclient
.message_type
9264 == dpyinfo
->Xatom_wm_protocols
9265 && event
.xclient
.format
== 32)
9267 if (event
.xclient
.data
.l
[0]
9268 == dpyinfo
->Xatom_wm_take_focus
)
9270 /* Use x_any_window_to_frame because this
9271 could be the shell widget window
9272 if the frame has no title bar. */
9273 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
9275 /* Not quite sure this is needed -pd */
9276 if (f
&& FRAME_XIC (f
))
9277 XSetICFocus (FRAME_XIC (f
));
9279 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
9280 instructs the WM to set the input focus automatically for
9281 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
9282 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
9283 it has set the focus. So, XSetInputFocus below is not
9286 The call to XSetInputFocus below has also caused trouble. In
9287 cases where the XSetInputFocus done by the WM and the one
9288 below are temporally close (on a fast machine), the call
9289 below can generate additional FocusIn events which confuse
9292 /* Since we set WM_TAKE_FOCUS, we must call
9293 XSetInputFocus explicitly. But not if f is null,
9294 since that might be an event for a deleted frame. */
9297 Display
*d
= event
.xclient
.display
;
9298 /* Catch and ignore errors, in case window has been
9299 iconified by a window manager such as GWM. */
9300 int count
= x_catch_errors (d
);
9301 XSetInputFocus (d
, event
.xclient
.window
,
9302 /* The ICCCM says this is
9303 the only valid choice. */
9305 event
.xclient
.data
.l
[1]);
9306 /* This is needed to detect the error
9307 if there is an error. */
9309 x_uncatch_errors (d
, count
);
9311 /* Not certain about handling scroll bars here */
9314 else if (event
.xclient
.data
.l
[0]
9315 == dpyinfo
->Xatom_wm_save_yourself
)
9317 /* Save state modify the WM_COMMAND property to
9318 something which can reinstate us. This notifies
9319 the session manager, who's looking for such a
9320 PropertyNotify. Can restart processing when
9321 a keyboard or mouse event arrives. */
9324 f
= x_top_window_to_frame (dpyinfo
,
9325 event
.xclient
.window
);
9327 /* This is just so we only give real data once
9328 for a single Emacs process. */
9329 if (f
== SELECTED_FRAME ())
9330 XSetCommand (FRAME_X_DISPLAY (f
),
9331 event
.xclient
.window
,
9332 initial_argv
, initial_argc
);
9334 XSetCommand (FRAME_X_DISPLAY (f
),
9335 event
.xclient
.window
,
9339 else if (event
.xclient
.data
.l
[0]
9340 == dpyinfo
->Xatom_wm_delete_window
)
9343 = x_any_window_to_frame (dpyinfo
,
9344 event
.xclient
.window
);
9351 bufp
->kind
= delete_window_event
;
9352 XSETFRAME (bufp
->frame_or_window
, f
);
9361 else if (event
.xclient
.message_type
9362 == dpyinfo
->Xatom_wm_configure_denied
)
9365 else if (event
.xclient
.message_type
9366 == dpyinfo
->Xatom_wm_window_moved
)
9370 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9372 new_x
= event
.xclient
.data
.s
[0];
9373 new_y
= event
.xclient
.data
.s
[1];
9377 f
->output_data
.x
->left_pos
= new_x
;
9378 f
->output_data
.x
->top_pos
= new_y
;
9382 else if (event
.xclient
.message_type
9383 == dpyinfo
->Xatom_editres
)
9386 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
9387 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
9390 #endif /* HACK_EDITRES */
9391 else if ((event
.xclient
.message_type
9392 == dpyinfo
->Xatom_DONE
)
9393 || (event
.xclient
.message_type
9394 == dpyinfo
->Xatom_PAGE
))
9396 /* Ghostview job completed. Kill it. We could
9397 reply with "Next" if we received "Page", but we
9398 currently never do because we are interested in
9399 images, only, which should have 1 page. */
9400 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
9402 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9403 x_kill_gs_process (pixmap
, f
);
9404 expose_frame (f
, 0, 0, 0, 0);
9406 #ifdef USE_TOOLKIT_SCROLL_BARS
9407 /* Scroll bar callbacks send a ClientMessage from which
9408 we construct an input_event. */
9409 else if (event
.xclient
.message_type
9410 == dpyinfo
->Xatom_Scrollbar
)
9412 x_scroll_bar_to_input_event (&event
, bufp
);
9413 ++bufp
, ++count
, --numchars
;
9416 #endif /* USE_TOOLKIT_SCROLL_BARS */
9422 case SelectionNotify
:
9423 #ifdef USE_X_TOOLKIT
9424 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
9426 #endif /* not USE_X_TOOLKIT */
9427 x_handle_selection_notify (&event
.xselection
);
9430 case SelectionClear
: /* Someone has grabbed ownership. */
9431 #ifdef USE_X_TOOLKIT
9432 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
9434 #endif /* USE_X_TOOLKIT */
9436 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
9441 bufp
->kind
= selection_clear_event
;
9442 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
9443 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
9444 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
9445 bufp
->frame_or_window
= Qnil
;
9454 case SelectionRequest
: /* Someone wants our selection. */
9455 #ifdef USE_X_TOOLKIT
9456 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
9458 #endif /* USE_X_TOOLKIT */
9459 if (x_queue_selection_requests
)
9460 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
9464 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
9469 bufp
->kind
= selection_request_event
;
9470 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
9471 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
9472 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
9473 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
9474 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
9475 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
9476 bufp
->frame_or_window
= Qnil
;
9485 case PropertyNotify
:
9486 #ifdef USE_X_TOOLKIT
9487 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
9489 #endif /* not USE_X_TOOLKIT */
9490 x_handle_property_notify (&event
.xproperty
);
9493 case ReparentNotify
:
9494 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
9498 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
9499 x_real_positions (f
, &x
, &y
);
9500 f
->output_data
.x
->left_pos
= x
;
9501 f
->output_data
.x
->top_pos
= y
;
9506 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
9509 if (f
->async_visible
== 0)
9511 f
->async_visible
= 1;
9512 f
->async_iconified
= 0;
9513 f
->output_data
.x
->has_been_visible
= 1;
9514 SET_FRAME_GARBAGED (f
);
9517 expose_frame (x_window_to_frame (dpyinfo
,
9518 event
.xexpose
.window
),
9519 event
.xexpose
.x
, event
.xexpose
.y
,
9520 event
.xexpose
.width
, event
.xexpose
.height
);
9524 #ifdef USE_TOOLKIT_SCROLL_BARS
9525 /* Dispatch event to the widget. */
9527 #else /* not USE_TOOLKIT_SCROLL_BARS */
9528 struct scroll_bar
*bar
9529 = x_window_to_scroll_bar (event
.xexpose
.window
);
9532 x_scroll_bar_expose (bar
, &event
);
9533 #ifdef USE_X_TOOLKIT
9536 #endif /* USE_X_TOOLKIT */
9537 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9541 case GraphicsExpose
: /* This occurs when an XCopyArea's
9542 source area was obscured or not
9544 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
9548 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
9549 event
.xgraphicsexpose
.width
,
9550 event
.xgraphicsexpose
.height
);
9552 #ifdef USE_X_TOOLKIT
9555 #endif /* USE_X_TOOLKIT */
9558 case NoExpose
: /* This occurs when an XCopyArea's
9559 source area was completely
9564 /* Redo the mouse-highlight after the tooltip has gone. */
9565 if (event
.xmap
.window
== tip_window
)
9568 redo_mouse_highlight ();
9571 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
9572 if (f
) /* F may no longer exist if
9573 the frame was deleted. */
9575 /* While a frame is unmapped, display generation is
9576 disabled; you don't want to spend time updating a
9577 display that won't ever be seen. */
9578 f
->async_visible
= 0;
9579 /* We can't distinguish, from the event, whether the window
9580 has become iconified or invisible. So assume, if it
9581 was previously visible, than now it is iconified.
9582 But x_make_frame_invisible clears both
9583 the visible flag and the iconified flag;
9584 and that way, we know the window is not iconified now. */
9585 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
9587 f
->async_iconified
= 1;
9589 bufp
->kind
= iconify_event
;
9590 XSETFRAME (bufp
->frame_or_window
, f
);
9600 if (event
.xmap
.window
== tip_window
)
9601 /* The tooltip has been drawn already. Avoid
9602 the SET_FRAME_GARBAGED below. */
9605 /* We use x_top_window_to_frame because map events can
9606 come for sub-windows and they don't mean that the
9607 frame is visible. */
9608 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
9611 f
->async_visible
= 1;
9612 f
->async_iconified
= 0;
9613 f
->output_data
.x
->has_been_visible
= 1;
9615 /* wait_reading_process_input will notice this and update
9616 the frame's display structures. */
9617 SET_FRAME_GARBAGED (f
);
9621 bufp
->kind
= deiconify_event
;
9622 XSETFRAME (bufp
->frame_or_window
, f
);
9628 else if (! NILP (Vframe_list
)
9629 && ! NILP (XCDR (Vframe_list
)))
9630 /* Force a redisplay sooner or later
9631 to update the frame titles
9632 in case this is the second frame. */
9633 record_asynch_buffer_change ();
9638 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
9641 /* I couldn't find a way to prevent LessTif scroll bars
9642 from consuming key events. */
9645 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
9647 if (widget
&& XmIsScrollBar (widget
))
9649 widget
= XtParent (widget
);
9650 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
9653 #endif /* USE_MOTIF */
9657 KeySym keysym
, orig_keysym
;
9658 /* al%imercury@uunet.uu.net says that making this 81
9659 instead of 80 fixed a bug whereby meta chars made
9662 It seems that some version of XmbLookupString has
9663 a bug of not returning XBufferOverflow in
9664 status_return even if the input is too long to
9665 fit in 81 bytes. So, we must prepare sufficient
9666 bytes for copy_buffer. 513 bytes (256 chars for
9667 two-byte character set) seems to be a faily good
9668 approximation. -- 2000.8.10 handa@etl.go.jp */
9669 unsigned char copy_buffer
[513];
9670 unsigned char *copy_bufptr
= copy_buffer
;
9671 int copy_bufsiz
= sizeof (copy_buffer
);
9675 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
9676 extra_keyboard_modifiers
);
9677 modifiers
= event
.xkey
.state
;
9679 /* This will have to go some day... */
9681 /* make_lispy_event turns chars into control chars.
9682 Don't do it here because XLookupString is too eager. */
9683 event
.xkey
.state
&= ~ControlMask
;
9684 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
9685 | dpyinfo
->super_mod_mask
9686 | dpyinfo
->hyper_mod_mask
9687 | dpyinfo
->alt_mod_mask
);
9689 /* In case Meta is ComposeCharacter,
9690 clear its status. According to Markus Ehrnsperger
9691 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
9692 this enables ComposeCharacter to work whether or
9693 not it is combined with Meta. */
9694 if (modifiers
& dpyinfo
->meta_mod_mask
)
9695 bzero (&compose_status
, sizeof (compose_status
));
9700 Status status_return
;
9702 nbytes
= XmbLookupString (FRAME_XIC (f
),
9703 &event
.xkey
, copy_bufptr
,
9704 copy_bufsiz
, &keysym
,
9706 if (status_return
== XBufferOverflow
)
9708 copy_bufsiz
= nbytes
+ 1;
9709 copy_bufptr
= (char *) alloca (copy_bufsiz
);
9710 nbytes
= XmbLookupString (FRAME_XIC (f
),
9711 &event
.xkey
, copy_bufptr
,
9712 copy_bufsiz
, &keysym
,
9716 if (status_return
== XLookupNone
)
9718 else if (status_return
== XLookupChars
)
9723 else if (status_return
!= XLookupKeySym
9724 && status_return
!= XLookupBoth
)
9728 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
9729 copy_bufsiz
, &keysym
,
9732 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
9733 copy_bufsiz
, &keysym
,
9737 orig_keysym
= keysym
;
9741 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
9742 || keysym
== XK_Delete
9743 #ifdef XK_ISO_Left_Tab
9744 || (keysym
>= XK_ISO_Left_Tab
&& keysym
<= XK_ISO_Enter
)
9746 || (keysym
>= XK_Kanji
&& keysym
<= XK_Eisu_toggle
)
9747 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
9748 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
9750 /* This recognizes the "extended function keys".
9751 It seems there's no cleaner way.
9752 Test IsModifierKey to avoid handling mode_switch
9754 || ((unsigned) (keysym
) >= XK_Select
9755 && (unsigned)(keysym
) < XK_KP_Space
)
9757 #ifdef XK_dead_circumflex
9758 || orig_keysym
== XK_dead_circumflex
9760 #ifdef XK_dead_grave
9761 || orig_keysym
== XK_dead_grave
9763 #ifdef XK_dead_tilde
9764 || orig_keysym
== XK_dead_tilde
9766 #ifdef XK_dead_diaeresis
9767 || orig_keysym
== XK_dead_diaeresis
9769 #ifdef XK_dead_macron
9770 || orig_keysym
== XK_dead_macron
9772 #ifdef XK_dead_degree
9773 || orig_keysym
== XK_dead_degree
9775 #ifdef XK_dead_acute
9776 || orig_keysym
== XK_dead_acute
9778 #ifdef XK_dead_cedilla
9779 || orig_keysym
== XK_dead_cedilla
9781 #ifdef XK_dead_breve
9782 || orig_keysym
== XK_dead_breve
9784 #ifdef XK_dead_ogonek
9785 || orig_keysym
== XK_dead_ogonek
9787 #ifdef XK_dead_caron
9788 || orig_keysym
== XK_dead_caron
9790 #ifdef XK_dead_doubleacute
9791 || orig_keysym
== XK_dead_doubleacute
9793 #ifdef XK_dead_abovedot
9794 || orig_keysym
== XK_dead_abovedot
9796 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
9797 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
9798 /* Any "vendor-specific" key is ok. */
9799 || (orig_keysym
& (1 << 28)))
9800 && ! (IsModifierKey (orig_keysym
)
9802 #ifdef XK_Mode_switch
9803 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
9806 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
9808 #endif /* not HAVE_X11R5 */
9811 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
9813 temp_buffer
[temp_index
++] = keysym
;
9814 bufp
->kind
= non_ascii_keystroke
;
9815 bufp
->code
= keysym
;
9816 XSETFRAME (bufp
->frame_or_window
, f
);
9819 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
9821 bufp
->timestamp
= event
.xkey
.time
;
9826 else if (numchars
> nbytes
)
9830 unsigned char *p
, *pend
;
9833 for (i
= 0; i
< nbytes
; i
++)
9835 if (temp_index
== (sizeof temp_buffer
9838 temp_buffer
[temp_index
++] = copy_bufptr
[i
];
9841 if (/* If the event is not from XIM, */
9842 event
.xkey
.keycode
!= 0
9843 /* or the current locale doesn't request
9844 decoding of the intup data, ... */
9845 || coding
.type
== coding_type_raw_text
9846 || coding
.type
== coding_type_no_conversion
)
9848 /* ... we can use the input data as is. */
9853 /* We have to decode the input data. */
9857 require
= decoding_buffer_size (&coding
, nbytes
);
9858 p
= (unsigned char *) alloca (require
);
9859 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
9860 decode_coding (&coding
, copy_bufptr
, p
,
9862 nbytes
= coding
.produced
;
9863 nchars
= coding
.produced_char
;
9867 /* Convert the input data to a sequence of
9868 character events. */
9869 for (i
= 0; i
< nbytes
; i
+= len
)
9871 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
9873 bufp
->kind
= (SINGLE_BYTE_CHAR_P (c
)
9875 : multibyte_char_keystroke
);
9877 XSETFRAME (bufp
->frame_or_window
, f
);
9880 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
9882 bufp
->timestamp
= event
.xkey
.time
;
9889 if (keysym
== NoSymbol
)
9899 /* Don't dispatch this event since XtDispatchEvent calls
9900 XFilterEvent, and two calls in a row may freeze the
9909 /* Don't dispatch this event since XtDispatchEvent calls
9910 XFilterEvent, and two calls in a row may freeze the
9917 /* Here's a possible interpretation of the whole
9918 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If
9919 you get a FocusIn event, you have to get a FocusOut
9920 event before you relinquish the focus. If you
9921 haven't received a FocusIn event, then a mere
9922 LeaveNotify is enough to free you. */
9926 int from_menu_bar_p
= 0;
9928 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
9930 #ifdef LESSTIF_VERSION
9931 /* When clicking outside of a menu bar popup to close
9932 it, we get a FocusIn/ EnterNotify sequence of
9933 events. The flag event.xcrossing.focus is not set
9934 in the EnterNotify event of that sequence because
9935 the focus is in the menu bar,
9936 event.xcrossing.window is the frame's X window.
9937 Unconditionally setting the focus frame to null in
9938 this case is not the right thing, because no event
9939 follows that could set the focus frame to the right
9942 This could be a LessTif bug, but I wasn't able to
9943 reproduce the behavior in a simple test program.
9945 (gerd, LessTif 0.88.1). */
9947 if (!event
.xcrossing
.focus
9949 && f
->output_data
.x
->menubar_widget
)
9954 XGetInputFocus (FRAME_X_DISPLAY (f
), &focus
, &revert
);
9955 if (focus
== XtWindow (f
->output_data
.x
->menubar_widget
))
9956 from_menu_bar_p
= 1;
9958 #endif /* LESSTIF_VERSION */
9960 if (event
.xcrossing
.focus
|| from_menu_bar_p
)
9962 /* Avoid nasty pop/raise loops. */
9963 if (f
&& (!(f
->auto_raise
)
9965 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
9967 x_new_focus_frame (dpyinfo
, f
);
9968 enter_timestamp
= event
.xcrossing
.time
;
9971 else if (f
== dpyinfo
->x_focus_frame
)
9972 x_new_focus_frame (dpyinfo
, 0);
9974 /* EnterNotify counts as mouse movement,
9975 so update things that depend on mouse position. */
9976 if (f
&& !f
->output_data
.x
->busy_p
)
9977 note_mouse_movement (f
, &event
.xmotion
);
9982 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
9983 if (event
.xfocus
.detail
!= NotifyPointer
)
9984 dpyinfo
->x_focus_event_frame
= f
;
9987 x_new_focus_frame (dpyinfo
, f
);
9989 /* Don't stop displaying the initial startup message
9990 for a switch-frame event we don't need. */
9991 if (GC_NILP (Vterminal_frame
)
9992 && GC_CONSP (Vframe_list
)
9993 && !GC_NILP (XCDR (Vframe_list
)))
9995 bufp
->kind
= FOCUS_IN_EVENT
;
9996 XSETFRAME (bufp
->frame_or_window
, f
);
9998 ++bufp
, ++count
, --numchars
;
10003 if (f
&& FRAME_XIC (f
))
10004 XSetICFocus (FRAME_XIC (f
));
10010 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10014 int from_menu_bar_p
= 0;
10016 if (f
== dpyinfo
->mouse_face_mouse_frame
)
10018 /* If we move outside the frame, then we're
10019 certainly no longer on any text in the frame. */
10020 clear_mouse_face (dpyinfo
);
10021 dpyinfo
->mouse_face_mouse_frame
= 0;
10024 /* Generate a nil HELP_EVENT to cancel a help-echo.
10025 Do it only if there's something to cancel.
10026 Otherwise, the startup message is cleared when
10027 the mouse leaves the frame. */
10028 if (any_help_event_p
)
10033 XSETFRAME (frame
, f
);
10034 n
= gen_help_event (bufp
, numchars
,
10035 Qnil
, frame
, Qnil
, Qnil
, 0);
10036 bufp
+= n
, count
+= n
, numchars
-= n
;
10039 #ifdef LESSTIF_VERSION
10040 /* Please see the comment at the start of the
10041 EnterNotify case. */
10042 if (!event
.xcrossing
.focus
10043 && f
->output_data
.x
->menubar_widget
)
10047 XGetInputFocus (FRAME_X_DISPLAY (f
), &focus
, &revert
);
10048 if (focus
== XtWindow (f
->output_data
.x
->menubar_widget
))
10049 from_menu_bar_p
= 1;
10051 #endif /* LESSTIF_VERSION */
10053 if (event
.xcrossing
.focus
|| from_menu_bar_p
)
10054 x_mouse_leave (dpyinfo
);
10057 if (f
== dpyinfo
->x_focus_event_frame
)
10058 dpyinfo
->x_focus_event_frame
= 0;
10059 if (f
== dpyinfo
->x_focus_frame
)
10060 x_new_focus_frame (dpyinfo
, 0);
10066 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
10067 if (event
.xfocus
.detail
!= NotifyPointer
10068 && f
== dpyinfo
->x_focus_event_frame
)
10069 dpyinfo
->x_focus_event_frame
= 0;
10070 if (f
&& f
== dpyinfo
->x_focus_frame
)
10071 x_new_focus_frame (dpyinfo
, 0);
10074 if (f
&& FRAME_XIC (f
))
10075 XUnsetICFocus (FRAME_XIC (f
));
10082 previous_help_echo
= help_echo
;
10083 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
10084 help_echo_pos
= -1;
10086 if (dpyinfo
->grabbed
&& last_mouse_frame
10087 && FRAME_LIVE_P (last_mouse_frame
))
10088 f
= last_mouse_frame
;
10090 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
10093 note_mouse_movement (f
, &event
.xmotion
);
10096 #ifndef USE_TOOLKIT_SCROLL_BARS
10097 struct scroll_bar
*bar
10098 = x_window_to_scroll_bar (event
.xmotion
.window
);
10101 x_scroll_bar_note_movement (bar
, &event
);
10102 #endif /* USE_TOOLKIT_SCROLL_BARS */
10104 /* If we move outside the frame, then we're
10105 certainly no longer on any text in the frame. */
10106 clear_mouse_face (dpyinfo
);
10109 /* If the contents of the global variable help_echo
10110 has changed, generate a HELP_EVENT. */
10111 if (!NILP (help_echo
)
10112 || !NILP (previous_help_echo
))
10118 XSETFRAME (frame
, f
);
10122 any_help_event_p
= 1;
10123 n
= gen_help_event (bufp
, numchars
, help_echo
, frame
,
10124 help_echo_window
, help_echo_object
,
10126 bufp
+= n
, count
+= n
, numchars
-= n
;
10132 case ConfigureNotify
:
10133 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
10136 #ifndef USE_X_TOOLKIT
10137 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
10138 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
10140 /* In the toolkit version, change_frame_size
10141 is called by the code that handles resizing
10142 of the EmacsFrame widget. */
10144 /* Even if the number of character rows and columns has
10145 not changed, the font size may have changed, so we need
10146 to check the pixel dimensions as well. */
10147 if (columns
!= f
->width
10148 || rows
!= f
->height
10149 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
10150 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
10152 change_frame_size (f
, rows
, columns
, 0, 1, 0);
10153 SET_FRAME_GARBAGED (f
);
10154 cancel_mouse_face (f
);
10158 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
10159 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
10161 /* What we have now is the position of Emacs's own window.
10162 Convert that to the position of the window manager window. */
10163 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
10164 &f
->output_data
.x
->top_pos
);
10167 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
10168 xic_set_statusarea (f
);
10171 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
10173 /* Since the WM decorations come below top_pos now,
10174 we must put them below top_pos in the future. */
10175 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
10176 x_wm_set_size_hint (f
, (long) 0, 0);
10179 /* Some window managers pass (0,0) as the location of
10180 the window, and the Motif event handler stores it
10181 in the emacs widget, which messes up Motif menus. */
10182 if (event
.xconfigure
.x
== 0 && event
.xconfigure
.y
== 0)
10184 event
.xconfigure
.x
= f
->output_data
.x
->widget
->core
.x
;
10185 event
.xconfigure
.y
= f
->output_data
.x
->widget
->core
.y
;
10187 #endif /* USE_MOTIF */
10192 case ButtonRelease
:
10194 /* If we decide we want to generate an event to be seen
10195 by the rest of Emacs, we put it here. */
10196 struct input_event emacs_event
;
10197 int tool_bar_p
= 0;
10199 emacs_event
.kind
= no_event
;
10200 bzero (&compose_status
, sizeof (compose_status
));
10202 if (dpyinfo
->grabbed
10203 && last_mouse_frame
10204 && FRAME_LIVE_P (last_mouse_frame
))
10205 f
= last_mouse_frame
;
10207 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
10211 /* Is this in the tool-bar? */
10212 if (WINDOWP (f
->tool_bar_window
)
10213 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
10215 Lisp_Object window
;
10218 x
= event
.xbutton
.x
;
10219 y
= event
.xbutton
.y
;
10222 window
= window_from_coordinates (f
, x
, y
, &p
, 1);
10223 if (EQ (window
, f
->tool_bar_window
))
10225 x_handle_tool_bar_click (f
, &event
.xbutton
);
10231 if (!dpyinfo
->x_focus_frame
10232 || f
== dpyinfo
->x_focus_frame
)
10233 construct_mouse_click (&emacs_event
, &event
, f
);
10237 #ifndef USE_TOOLKIT_SCROLL_BARS
10238 struct scroll_bar
*bar
10239 = x_window_to_scroll_bar (event
.xbutton
.window
);
10242 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
10243 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10246 if (event
.type
== ButtonPress
)
10248 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
10249 last_mouse_frame
= f
;
10250 /* Ignore any mouse motion that happened
10251 before this event; any subsequent mouse-movement
10252 Emacs events should reflect only motion after
10253 the ButtonPress. */
10255 f
->mouse_moved
= 0;
10258 last_tool_bar_item
= -1;
10262 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
10265 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
10267 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
10273 #ifdef USE_X_TOOLKIT
10274 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
10275 /* For a down-event in the menu bar,
10276 don't pass it to Xt right now.
10277 Instead, save it away
10278 and we will pass it to Xt from kbd_buffer_get_event.
10279 That way, we can run some Lisp code first. */
10280 if (f
&& event
.type
== ButtonPress
10281 /* Verify the event is really within the menu bar
10282 and not just sent to it due to grabbing. */
10283 && event
.xbutton
.x
>= 0
10284 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
10285 && event
.xbutton
.y
>= 0
10286 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
10287 && event
.xbutton
.same_screen
)
10289 SET_SAVED_BUTTON_EVENT
;
10290 XSETFRAME (last_mouse_press_frame
, f
);
10292 else if (event
.type
== ButtonPress
)
10294 last_mouse_press_frame
= Qnil
;
10298 #ifdef USE_MOTIF /* This should do not harm for Lucid,
10299 but I am trying to be cautious. */
10300 else if (event
.type
== ButtonRelease
)
10302 if (!NILP (last_mouse_press_frame
))
10304 f
= XFRAME (last_mouse_press_frame
);
10305 if (f
->output_data
.x
)
10306 SET_SAVED_BUTTON_EVENT
;
10311 #endif /* USE_MOTIF */
10314 #endif /* USE_X_TOOLKIT */
10318 case CirculateNotify
:
10321 case CirculateRequest
:
10324 case VisibilityNotify
:
10327 case MappingNotify
:
10328 /* Someone has changed the keyboard mapping - update the
10330 switch (event
.xmapping
.request
)
10332 case MappingModifier
:
10333 x_find_modifier_meanings (dpyinfo
);
10334 /* This is meant to fall through. */
10335 case MappingKeyboard
:
10336 XRefreshKeyboardMapping (&event
.xmapping
);
10342 #ifdef USE_X_TOOLKIT
10344 XtDispatchEvent (&event
);
10346 #endif /* USE_X_TOOLKIT */
10354 /* On some systems, an X bug causes Emacs to get no more events
10355 when the window is destroyed. Detect that. (1994.) */
10358 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
10359 One XNOOP in 100 loops will make Emacs terminate.
10360 B. Bretthauer, 1994 */
10362 if (x_noop_count
>= 100)
10366 if (next_noop_dpyinfo
== 0)
10367 next_noop_dpyinfo
= x_display_list
;
10369 XNoOp (next_noop_dpyinfo
->display
);
10371 /* Each time we get here, cycle through the displays now open. */
10372 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
10376 /* If the focus was just given to an auto-raising frame,
10378 /* ??? This ought to be able to handle more than one such frame. */
10379 if (pending_autoraise_frame
)
10381 x_raise_frame (pending_autoraise_frame
);
10382 pending_autoraise_frame
= 0;
10393 /***********************************************************************
10395 ***********************************************************************/
10397 /* Note if the text cursor of window W has been overwritten by a
10398 drawing operation that outputs N glyphs starting at HPOS in the
10399 line given by output_cursor.vpos. N < 0 means all the rest of the
10400 line after HPOS has been written. */
10403 note_overwritten_text_cursor (w
, hpos
, n
)
10407 if (updated_area
== TEXT_AREA
10408 && output_cursor
.vpos
== w
->phys_cursor
.vpos
10409 && hpos
<= w
->phys_cursor
.hpos
10411 || hpos
+ n
> w
->phys_cursor
.hpos
))
10412 w
->phys_cursor_on_p
= 0;
10416 /* Set clipping for output in glyph row ROW. W is the window in which
10417 we operate. GC is the graphics context to set clipping in.
10418 WHOLE_LINE_P non-zero means include the areas used for truncation
10419 mark display and alike in the clipping rectangle.
10421 ROW may be a text row or, e.g., a mode line. Text rows must be
10422 clipped to the interior of the window dedicated to text display,
10423 mode lines must be clipped to the whole window. */
10426 x_clip_to_row (w
, row
, gc
, whole_line_p
)
10428 struct glyph_row
*row
;
10432 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10433 XRectangle clip_rect
;
10434 int window_x
, window_y
, window_width
, window_height
;
10436 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
10438 clip_rect
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
10439 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
10440 clip_rect
.y
= max (clip_rect
.y
, window_y
);
10441 clip_rect
.width
= window_width
;
10442 clip_rect
.height
= row
->visible_height
;
10444 /* If clipping to the whole line, including trunc marks, extend
10445 the rectangle to the left and increase its width. */
10448 clip_rect
.x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
10449 clip_rect
.width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
10452 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
10456 /* Draw a hollow box cursor on window W in glyph row ROW. */
10459 x_draw_hollow_cursor (w
, row
)
10461 struct glyph_row
*row
;
10463 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10464 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10465 Display
*dpy
= FRAME_X_DISPLAY (f
);
10468 struct glyph
*cursor_glyph
;
10471 /* Compute frame-relative coordinates from window-relative
10473 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
10474 y
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
10475 + row
->ascent
- w
->phys_cursor_ascent
);
10476 h
= row
->height
- 1;
10478 /* Get the glyph the cursor is on. If we can't tell because
10479 the current matrix is invalid or such, give up. */
10480 cursor_glyph
= get_phys_cursor_glyph (w
);
10481 if (cursor_glyph
== NULL
)
10484 /* Compute the width of the rectangle to draw. If on a stretch
10485 glyph, and `x-stretch-block-cursor' is nil, don't draw a
10486 rectangle as wide as the glyph, but use a canonical character
10488 wd
= cursor_glyph
->pixel_width
- 1;
10489 if (cursor_glyph
->type
== STRETCH_GLYPH
10490 && !x_stretch_cursor_p
)
10491 wd
= min (CANON_X_UNIT (f
), wd
);
10493 /* The foreground of cursor_gc is typically the same as the normal
10494 background color, which can cause the cursor box to be invisible. */
10495 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
10496 if (dpyinfo
->scratch_cursor_gc
)
10497 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
10499 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
10500 GCForeground
, &xgcv
);
10501 gc
= dpyinfo
->scratch_cursor_gc
;
10503 /* Set clipping, draw the rectangle, and reset clipping again. */
10504 x_clip_to_row (w
, row
, gc
, 0);
10505 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
10506 XSetClipMask (dpy
, gc
, None
);
10510 /* Draw a bar cursor on window W in glyph row ROW.
10512 Implementation note: One would like to draw a bar cursor with an
10513 angle equal to the one given by the font property XA_ITALIC_ANGLE.
10514 Unfortunately, I didn't find a font yet that has this property set.
10518 x_draw_bar_cursor (w
, row
, width
)
10520 struct glyph_row
*row
;
10523 struct frame
*f
= XFRAME (w
->frame
);
10524 struct glyph
*cursor_glyph
;
10527 unsigned long mask
;
10532 /* If cursor is out of bounds, don't draw garbage. This can happen
10533 in mini-buffer windows when switching between echo area glyphs
10534 and mini-buffer. */
10535 cursor_glyph
= get_phys_cursor_glyph (w
);
10536 if (cursor_glyph
== NULL
)
10539 /* If on an image, draw like a normal cursor. That's usually better
10540 visible than drawing a bar, esp. if the image is large so that
10541 the bar might not be in the window. */
10542 if (cursor_glyph
->type
== IMAGE_GLYPH
)
10544 struct glyph_row
*row
;
10545 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
10546 x_draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
10550 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
10551 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
10552 xgcv
.graphics_exposures
= 0;
10553 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
10554 dpy
= FRAME_X_DISPLAY (f
);
10555 window
= FRAME_X_WINDOW (f
);
10556 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
10559 XChangeGC (dpy
, gc
, mask
, &xgcv
);
10562 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
10563 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
10567 width
= f
->output_data
.x
->cursor_width
;
10569 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
10570 x_clip_to_row (w
, row
, gc
, 0);
10571 XFillRectangle (dpy
, window
, gc
,
10573 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
10574 min (cursor_glyph
->pixel_width
, width
),
10576 XSetClipMask (dpy
, gc
, None
);
10581 /* Clear the cursor of window W to background color, and mark the
10582 cursor as not shown. This is used when the text where the cursor
10583 is is about to be rewritten. */
10589 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
10590 x_update_window_cursor (w
, 0);
10594 /* Draw the cursor glyph of window W in glyph row ROW. See the
10595 comment of x_draw_glyphs for the meaning of HL. */
10598 x_draw_phys_cursor_glyph (w
, row
, hl
)
10600 struct glyph_row
*row
;
10601 enum draw_glyphs_face hl
;
10603 /* If cursor hpos is out of bounds, don't draw garbage. This can
10604 happen in mini-buffer windows when switching between echo area
10605 glyphs and mini-buffer. */
10606 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
10608 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
10609 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
10612 /* When we erase the cursor, and ROW is overlapped by other
10613 rows, make sure that these overlapping parts of other rows
10615 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
10617 if (row
> w
->current_matrix
->rows
10618 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
10619 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
10621 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
10622 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
10623 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
10629 /* Erase the image of a cursor of window W from the screen. */
10632 x_erase_phys_cursor (w
)
10635 struct frame
*f
= XFRAME (w
->frame
);
10636 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10637 int hpos
= w
->phys_cursor
.hpos
;
10638 int vpos
= w
->phys_cursor
.vpos
;
10639 int mouse_face_here_p
= 0;
10640 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
10641 struct glyph_row
*cursor_row
;
10642 struct glyph
*cursor_glyph
;
10643 enum draw_glyphs_face hl
;
10645 /* No cursor displayed or row invalidated => nothing to do on the
10647 if (w
->phys_cursor_type
== NO_CURSOR
)
10648 goto mark_cursor_off
;
10650 /* VPOS >= active_glyphs->nrows means that window has been resized.
10651 Don't bother to erase the cursor. */
10652 if (vpos
>= active_glyphs
->nrows
)
10653 goto mark_cursor_off
;
10655 /* If row containing cursor is marked invalid, there is nothing we
10657 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
10658 if (!cursor_row
->enabled_p
)
10659 goto mark_cursor_off
;
10661 /* This can happen when the new row is shorter than the old one.
10662 In this case, either x_draw_glyphs or clear_end_of_line
10663 should have cleared the cursor. Note that we wouldn't be
10664 able to erase the cursor in this case because we don't have a
10665 cursor glyph at hand. */
10666 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
10667 goto mark_cursor_off
;
10669 /* If the cursor is in the mouse face area, redisplay that when
10670 we clear the cursor. */
10671 if (! NILP (dpyinfo
->mouse_face_window
)
10672 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
10673 && (vpos
> dpyinfo
->mouse_face_beg_row
10674 || (vpos
== dpyinfo
->mouse_face_beg_row
10675 && hpos
>= dpyinfo
->mouse_face_beg_col
))
10676 && (vpos
< dpyinfo
->mouse_face_end_row
10677 || (vpos
== dpyinfo
->mouse_face_end_row
10678 && hpos
< dpyinfo
->mouse_face_end_col
))
10679 /* Don't redraw the cursor's spot in mouse face if it is at the
10680 end of a line (on a newline). The cursor appears there, but
10681 mouse highlighting does not. */
10682 && cursor_row
->used
[TEXT_AREA
] > hpos
)
10683 mouse_face_here_p
= 1;
10685 /* Maybe clear the display under the cursor. */
10686 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
10689 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
10691 cursor_glyph
= get_phys_cursor_glyph (w
);
10692 if (cursor_glyph
== NULL
)
10693 goto mark_cursor_off
;
10695 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
10697 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10699 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
10701 cursor_glyph
->pixel_width
,
10702 cursor_row
->visible_height
,
10706 /* Erase the cursor by redrawing the character underneath it. */
10707 if (mouse_face_here_p
)
10708 hl
= DRAW_MOUSE_FACE
;
10709 else if (cursor_row
->inverse_p
)
10710 hl
= DRAW_INVERSE_VIDEO
;
10712 hl
= DRAW_NORMAL_TEXT
;
10713 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
10716 w
->phys_cursor_on_p
= 0;
10717 w
->phys_cursor_type
= NO_CURSOR
;
10721 /* Display or clear cursor of window W. If ON is zero, clear the
10722 cursor. If it is non-zero, display the cursor. If ON is nonzero,
10723 where to put the cursor is specified by HPOS, VPOS, X and Y. */
10726 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
10728 int on
, hpos
, vpos
, x
, y
;
10730 struct frame
*f
= XFRAME (w
->frame
);
10731 int new_cursor_type
;
10732 int new_cursor_width
;
10733 struct glyph_matrix
*current_glyphs
;
10734 struct glyph_row
*glyph_row
;
10735 struct glyph
*glyph
;
10737 /* This is pointless on invisible frames, and dangerous on garbaged
10738 windows and frames; in the latter case, the frame or window may
10739 be in the midst of changing its size, and x and y may be off the
10741 if (! FRAME_VISIBLE_P (f
)
10742 || FRAME_GARBAGED_P (f
)
10743 || vpos
>= w
->current_matrix
->nrows
10744 || hpos
>= w
->current_matrix
->matrix_w
)
10747 /* If cursor is off and we want it off, return quickly. */
10748 if (!on
&& !w
->phys_cursor_on_p
)
10751 current_glyphs
= w
->current_matrix
;
10752 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
10753 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
10755 /* If cursor row is not enabled, we don't really know where to
10756 display the cursor. */
10757 if (!glyph_row
->enabled_p
)
10759 w
->phys_cursor_on_p
= 0;
10763 xassert (interrupt_input_blocked
);
10765 /* Set new_cursor_type to the cursor we want to be displayed. In a
10766 mini-buffer window, we want the cursor only to appear if we are
10767 reading input from this window. For the selected window, we want
10768 the cursor type given by the frame parameter. If explicitly
10769 marked off, draw no cursor. In all other cases, we want a hollow
10771 new_cursor_width
= -1;
10772 if (cursor_in_echo_area
10773 && FRAME_HAS_MINIBUF_P (f
)
10774 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
10776 if (w
== XWINDOW (echo_area_window
))
10777 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
10779 new_cursor_type
= HOLLOW_BOX_CURSOR
;
10783 if (w
!= XWINDOW (selected_window
)
10784 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
10786 extern int cursor_in_non_selected_windows
;
10788 if (MINI_WINDOW_P (w
)
10789 || !cursor_in_non_selected_windows
10790 || NILP (XBUFFER (w
->buffer
)->cursor_type
))
10791 new_cursor_type
= NO_CURSOR
;
10793 new_cursor_type
= HOLLOW_BOX_CURSOR
;
10795 else if (w
->cursor_off_p
)
10796 new_cursor_type
= NO_CURSOR
;
10799 struct buffer
*b
= XBUFFER (w
->buffer
);
10801 if (EQ (b
->cursor_type
, Qt
))
10802 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
10804 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
10805 &new_cursor_width
);
10809 /* If cursor is currently being shown and we don't want it to be or
10810 it is in the wrong place, or the cursor type is not what we want,
10812 if (w
->phys_cursor_on_p
10814 || w
->phys_cursor
.x
!= x
10815 || w
->phys_cursor
.y
!= y
10816 || new_cursor_type
!= w
->phys_cursor_type
))
10817 x_erase_phys_cursor (w
);
10819 /* If the cursor is now invisible and we want it to be visible,
10821 if (on
&& !w
->phys_cursor_on_p
)
10823 w
->phys_cursor_ascent
= glyph_row
->ascent
;
10824 w
->phys_cursor_height
= glyph_row
->height
;
10826 /* Set phys_cursor_.* before x_draw_.* is called because some
10827 of them may need the information. */
10828 w
->phys_cursor
.x
= x
;
10829 w
->phys_cursor
.y
= glyph_row
->y
;
10830 w
->phys_cursor
.hpos
= hpos
;
10831 w
->phys_cursor
.vpos
= vpos
;
10832 w
->phys_cursor_type
= new_cursor_type
;
10833 w
->phys_cursor_on_p
= 1;
10835 switch (new_cursor_type
)
10837 case HOLLOW_BOX_CURSOR
:
10838 x_draw_hollow_cursor (w
, glyph_row
);
10841 case FILLED_BOX_CURSOR
:
10842 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
10846 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
);
10857 if (w
== XWINDOW (f
->selected_window
))
10858 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
10859 xic_set_preeditarea (w
, x
, y
);
10864 if (updating_frame
!= f
)
10865 XFlush (FRAME_X_DISPLAY (f
));
10870 /* Display the cursor on window W, or clear it. X and Y are window
10871 relative pixel coordinates. HPOS and VPOS are glyph matrix
10872 positions. If W is not the selected window, display a hollow
10873 cursor. ON non-zero means display the cursor at X, Y which
10874 correspond to HPOS, VPOS, otherwise it is cleared. */
10877 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
10879 int on
, hpos
, vpos
, x
, y
;
10882 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
10887 /* Display the cursor on window W, or clear it, according to ON_P.
10888 Don't change the cursor's position. */
10891 x_update_cursor (f
, on_p
)
10894 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
10898 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
10899 in the window tree rooted at W. */
10902 x_update_cursor_in_window_tree (w
, on_p
)
10908 if (!NILP (w
->hchild
))
10909 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
10910 else if (!NILP (w
->vchild
))
10911 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
10913 x_update_window_cursor (w
, on_p
);
10915 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
10920 /* Switch the display of W's cursor on or off, according to the value
10924 x_update_window_cursor (w
, on
)
10928 /* Don't update cursor in windows whose frame is in the process
10929 of being deleted. */
10930 if (w
->current_matrix
)
10933 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
10934 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
10944 /* Refresh bitmap kitchen sink icon for frame F
10945 when we get an expose event for it. */
10951 /* Normally, the window manager handles this function. */
10954 /* Make the x-window of frame F use the gnu icon bitmap. */
10957 x_bitmap_icon (f
, file
)
10963 if (FRAME_X_WINDOW (f
) == 0)
10966 /* Free up our existing icon bitmap if any. */
10967 if (f
->output_data
.x
->icon_bitmap
> 0)
10968 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
10969 f
->output_data
.x
->icon_bitmap
= 0;
10971 if (STRINGP (file
))
10972 bitmap_id
= x_create_bitmap_from_file (f
, file
);
10975 /* Create the GNU bitmap if necessary. */
10976 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
10977 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
10978 = x_create_bitmap_from_data (f
, gnu_bits
,
10979 gnu_width
, gnu_height
);
10981 /* The first time we create the GNU bitmap,
10982 this increments the ref-count one extra time.
10983 As a result, the GNU bitmap is never freed.
10984 That way, we don't have to worry about allocating it again. */
10985 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
10987 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
10990 x_wm_set_icon_pixmap (f
, bitmap_id
);
10991 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
10997 /* Make the x-window of frame F use a rectangle with text.
10998 Use ICON_NAME as the text. */
11001 x_text_icon (f
, icon_name
)
11005 if (FRAME_X_WINDOW (f
) == 0)
11010 XTextProperty text
;
11011 text
.value
= (unsigned char *) icon_name
;
11012 text
.encoding
= XA_STRING
;
11014 text
.nitems
= strlen (icon_name
);
11015 #ifdef USE_X_TOOLKIT
11016 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
11018 #else /* not USE_X_TOOLKIT */
11019 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
11020 #endif /* not USE_X_TOOLKIT */
11022 #else /* not HAVE_X11R4 */
11023 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
11024 #endif /* not HAVE_X11R4 */
11026 if (f
->output_data
.x
->icon_bitmap
> 0)
11027 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
11028 f
->output_data
.x
->icon_bitmap
= 0;
11029 x_wm_set_icon_pixmap (f
, 0);
11034 #define X_ERROR_MESSAGE_SIZE 200
11036 /* If non-nil, this should be a string.
11037 It means catch X errors and store the error message in this string. */
11039 static Lisp_Object x_error_message_string
;
11041 /* An X error handler which stores the error message in
11042 x_error_message_string. This is called from x_error_handler if
11043 x_catch_errors is in effect. */
11046 x_error_catcher (display
, error
)
11048 XErrorEvent
*error
;
11050 XGetErrorText (display
, error
->error_code
,
11051 XSTRING (x_error_message_string
)->data
,
11052 X_ERROR_MESSAGE_SIZE
);
11055 /* Begin trapping X errors for display DPY. Actually we trap X errors
11056 for all displays, but DPY should be the display you are actually
11059 After calling this function, X protocol errors no longer cause
11060 Emacs to exit; instead, they are recorded in the string
11061 stored in x_error_message_string.
11063 Calling x_check_errors signals an Emacs error if an X error has
11064 occurred since the last call to x_catch_errors or x_check_errors.
11066 Calling x_uncatch_errors resumes the normal error handling. */
11068 void x_check_errors ();
11069 static Lisp_Object
x_catch_errors_unwind ();
11072 x_catch_errors (dpy
)
11075 int count
= specpdl_ptr
- specpdl
;
11077 /* Make sure any errors from previous requests have been dealt with. */
11078 XSync (dpy
, False
);
11080 record_unwind_protect (x_catch_errors_unwind
, x_error_message_string
);
11082 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
11083 XSTRING (x_error_message_string
)->data
[0] = 0;
11088 /* Unbind the binding that we made to check for X errors. */
11091 x_catch_errors_unwind (old_val
)
11092 Lisp_Object old_val
;
11094 x_error_message_string
= old_val
;
11098 /* If any X protocol errors have arrived since the last call to
11099 x_catch_errors or x_check_errors, signal an Emacs error using
11100 sprintf (a buffer, FORMAT, the x error message text) as the text. */
11103 x_check_errors (dpy
, format
)
11107 /* Make sure to catch any errors incurred so far. */
11108 XSync (dpy
, False
);
11110 if (XSTRING (x_error_message_string
)->data
[0])
11111 error (format
, XSTRING (x_error_message_string
)->data
);
11114 /* Nonzero if we had any X protocol errors
11115 since we did x_catch_errors on DPY. */
11118 x_had_errors_p (dpy
)
11121 /* Make sure to catch any errors incurred so far. */
11122 XSync (dpy
, False
);
11124 return XSTRING (x_error_message_string
)->data
[0] != 0;
11127 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
11130 x_clear_errors (dpy
)
11133 XSTRING (x_error_message_string
)->data
[0] = 0;
11136 /* Stop catching X protocol errors and let them make Emacs die.
11137 DPY should be the display that was passed to x_catch_errors.
11138 COUNT should be the value that was returned by
11139 the corresponding call to x_catch_errors. */
11142 x_uncatch_errors (dpy
, count
)
11146 unbind_to (count
, Qnil
);
11150 static unsigned int x_wire_count
;
11153 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
11158 /* Handle SIGPIPE, which can happen when the connection to a server
11159 simply goes away. SIGPIPE is handled by x_connection_signal.
11160 Don't need to do anything, because the write which caused the
11161 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
11162 which will do the appropriate cleanup for us. */
11165 x_connection_signal (signalnum
) /* If we don't have an argument, */
11166 int signalnum
; /* some compilers complain in signal calls. */
11169 /* USG systems forget handlers when they are used;
11170 must reestablish each time */
11171 signal (signalnum
, x_connection_signal
);
11175 /* Handling X errors. */
11177 /* Handle the loss of connection to display DISPLAY. */
11180 x_connection_closed (display
, error_message
)
11182 char *error_message
;
11184 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
11185 Lisp_Object frame
, tail
;
11187 /* Indicate that this display is dead. */
11189 #if 0 /* Closing the display caused a bus error on OpenWindows. */
11190 #ifdef USE_X_TOOLKIT
11191 XtCloseDisplay (display
);
11196 dpyinfo
->display
= 0;
11198 /* First delete frames whose mini-buffers are on frames
11199 that are on the dead display. */
11200 FOR_EACH_FRAME (tail
, frame
)
11202 Lisp_Object minibuf_frame
;
11204 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
11205 if (FRAME_X_P (XFRAME (frame
))
11206 && FRAME_X_P (XFRAME (minibuf_frame
))
11207 && ! EQ (frame
, minibuf_frame
)
11208 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
11209 Fdelete_frame (frame
, Qt
);
11212 /* Now delete all remaining frames on the dead display.
11213 We are now sure none of these is used as the mini-buffer
11214 for another frame that we need to delete. */
11215 FOR_EACH_FRAME (tail
, frame
)
11216 if (FRAME_X_P (XFRAME (frame
))
11217 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
11219 /* Set this to t so that Fdelete_frame won't get confused
11220 trying to find a replacement. */
11221 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
11222 Fdelete_frame (frame
, Qt
);
11226 x_delete_display (dpyinfo
);
11228 if (x_display_list
== 0)
11230 fprintf (stderr
, "%s\n", error_message
);
11231 shut_down_emacs (0, 0, Qnil
);
11235 /* Ordinary stack unwind doesn't deal with these. */
11237 sigunblock (sigmask (SIGIO
));
11239 sigunblock (sigmask (SIGALRM
));
11240 TOTALLY_UNBLOCK_INPUT
;
11242 clear_waiting_for_input ();
11243 handling_signal
= 0;
11244 error ("%s", error_message
);
11247 /* This is the usual handler for X protocol errors.
11248 It kills all frames on the display that we got the error for.
11249 If that was the only one, it prints an error message and kills Emacs. */
11252 x_error_quitter (display
, error
)
11254 XErrorEvent
*error
;
11256 char buf
[256], buf1
[356];
11258 /* Note that there is no real way portable across R3/R4 to get the
11259 original error handler. */
11261 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
11262 sprintf (buf1
, "X protocol error: %s on protocol request %d",
11263 buf
, error
->request_code
);
11264 x_connection_closed (display
, buf1
);
11267 /* This is the first-level handler for X protocol errors.
11268 It calls x_error_quitter or x_error_catcher. */
11271 x_error_handler (display
, error
)
11273 XErrorEvent
*error
;
11275 if (! NILP (x_error_message_string
))
11276 x_error_catcher (display
, error
);
11278 x_error_quitter (display
, error
);
11282 /* This is the handler for X IO errors, always.
11283 It kills all frames on the display that we lost touch with.
11284 If that was the only one, it prints an error message and kills Emacs. */
11287 x_io_error_quitter (display
)
11292 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
11293 x_connection_closed (display
, buf
);
11297 /* Changing the font of the frame. */
11299 /* Give frame F the font named FONTNAME as its default font, and
11300 return the full name of that font. FONTNAME may be a wildcard
11301 pattern; in that case, we choose some font that fits the pattern.
11302 The return value shows which font we chose. */
11305 x_new_font (f
, fontname
)
11307 register char *fontname
;
11309 struct font_info
*fontp
11310 = FS_LOAD_FONT (f
, 0, fontname
, -1);
11315 f
->output_data
.x
->font
= (XFontStruct
*) (fontp
->font
);
11316 f
->output_data
.x
->baseline_offset
= fontp
->baseline_offset
;
11317 f
->output_data
.x
->fontset
= -1;
11319 /* Compute the scroll bar width in character columns. */
11320 if (f
->scroll_bar_pixel_width
> 0)
11322 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
11323 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
11327 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
11328 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
11331 /* Now make the frame display the given font. */
11332 if (FRAME_X_WINDOW (f
) != 0)
11334 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
11335 f
->output_data
.x
->font
->fid
);
11336 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
11337 f
->output_data
.x
->font
->fid
);
11338 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
11339 f
->output_data
.x
->font
->fid
);
11341 frame_update_line_height (f
);
11342 x_set_window_size (f
, 0, f
->width
, f
->height
);
11345 /* If we are setting a new frame's font for the first time,
11346 there are no faces yet, so this font's height is the line height. */
11347 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
11349 return build_string (fontp
->full_name
);
11352 /* Give frame F the fontset named FONTSETNAME as its default font, and
11353 return the full name of that fontset. FONTSETNAME may be a wildcard
11354 pattern; in that case, we choose some fontset that fits the pattern.
11355 The return value shows which fontset we chose. */
11358 x_new_fontset (f
, fontsetname
)
11362 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
11363 Lisp_Object result
;
11368 if (f
->output_data
.x
->fontset
== fontset
)
11369 /* This fontset is already set in frame F. There's nothing more
11371 return fontset_name (fontset
);
11373 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
11375 if (!STRINGP (result
))
11376 /* Can't load ASCII font. */
11379 /* Since x_new_font doesn't update any fontset information, do it now. */
11380 f
->output_data
.x
->fontset
= fontset
;
11384 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
11385 xic_set_xfontset (f
, XSTRING (fontset_ascii (fontset
))->data
);
11388 return build_string (fontsetname
);
11392 /***********************************************************************
11394 ***********************************************************************/
11400 /* XIM destroy callback function, which is called whenever the
11401 connection to input method XIM dies. CLIENT_DATA contains a
11402 pointer to the x_display_info structure corresponding to XIM. */
11405 xim_destroy_callback (xim
, client_data
, call_data
)
11407 XPointer client_data
;
11408 XPointer call_data
;
11410 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
11411 Lisp_Object frame
, tail
;
11415 /* No need to call XDestroyIC.. */
11416 FOR_EACH_FRAME (tail
, frame
)
11418 struct frame
*f
= XFRAME (frame
);
11419 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
11421 FRAME_XIC (f
) = NULL
;
11422 if (FRAME_XIC_FONTSET (f
))
11424 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
11425 FRAME_XIC_FONTSET (f
) = NULL
;
11430 /* No need to call XCloseIM. */
11431 dpyinfo
->xim
= NULL
;
11432 XFree (dpyinfo
->xim_styles
);
11436 #endif /* HAVE_X11R6 */
11438 /* Open the connection to the XIM server on display DPYINFO.
11439 RESOURCE_NAME is the resource name Emacs uses. */
11442 xim_open_dpy (dpyinfo
, resource_name
)
11443 struct x_display_info
*dpyinfo
;
11444 char *resource_name
;
11449 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
, EMACS_CLASS
);
11450 dpyinfo
->xim
= xim
;
11455 XIMCallback destroy
;
11458 /* Get supported styles and XIM values. */
11459 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
11462 destroy
.callback
= xim_destroy_callback
;
11463 destroy
.client_data
= (XPointer
)dpyinfo
;
11464 /* This isn't prptotyped in OSF 5.0. */
11465 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
11469 #else /* not USE_XIM */
11470 dpyinfo
->xim
= NULL
;
11471 #endif /* not USE_XIM */
11475 #ifdef HAVE_X11R6_XIM
11479 struct x_display_info
*dpyinfo
;
11480 char *resource_name
;
11483 /* XIM instantiate callback function, which is called whenever an XIM
11484 server is available. DISPLAY is teh display of the XIM.
11485 CLIENT_DATA contains a pointer to an xim_inst_t structure created
11486 when the callback was registered. */
11489 xim_instantiate_callback (display
, client_data
, call_data
)
11491 XPointer client_data
;
11492 XPointer call_data
;
11494 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
11495 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
11497 /* We don't support multiple XIM connections. */
11501 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
11503 /* Create XIC for the existing frames on the same display, as long
11504 as they have no XIC. */
11505 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
11507 Lisp_Object tail
, frame
;
11510 FOR_EACH_FRAME (tail
, frame
)
11512 struct frame
*f
= XFRAME (frame
);
11514 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
11515 if (FRAME_XIC (f
) == NULL
)
11517 create_frame_xic (f
);
11518 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
11519 xic_set_statusarea (f
);
11520 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
11522 struct window
*w
= XWINDOW (f
->selected_window
);
11523 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
11532 #endif /* HAVE_X11R6_XIM */
11535 /* Open a connection to the XIM server on display DPYINFO.
11536 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
11537 connection only at the first time. On X11R6, open the connection
11538 in the XIM instantiate callback function. */
11541 xim_initialize (dpyinfo
, resource_name
)
11542 struct x_display_info
*dpyinfo
;
11543 char *resource_name
;
11546 #ifdef HAVE_X11R6_XIM
11547 struct xim_inst_t
*xim_inst
;
11550 dpyinfo
->xim
= NULL
;
11551 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
11552 xim_inst
->dpyinfo
= dpyinfo
;
11553 len
= strlen (resource_name
);
11554 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
11555 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
11556 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
11557 resource_name
, EMACS_CLASS
,
11558 xim_instantiate_callback
,
11559 /* Fixme: This is XPointer in
11560 XFree86 but (XPointer *) on
11561 Tru64, at least. */
11562 (XPointer
) xim_inst
);
11563 #else /* not HAVE_X11R6_XIM */
11564 dpyinfo
->xim
= NULL
;
11565 xim_open_dpy (dpyinfo
, resource_name
);
11566 #endif /* not HAVE_X11R6_XIM */
11568 #else /* not USE_XIM */
11569 dpyinfo
->xim
= NULL
;
11570 #endif /* not USE_XIM */
11574 /* Close the connection to the XIM server on display DPYINFO. */
11577 xim_close_dpy (dpyinfo
)
11578 struct x_display_info
*dpyinfo
;
11581 #ifdef HAVE_X11R6_XIM
11582 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
11584 xim_instantiate_callback
, NULL
);
11585 #endif /* not HAVE_X11R6_XIM */
11586 XCloseIM (dpyinfo
->xim
);
11587 dpyinfo
->xim
= NULL
;
11588 XFree (dpyinfo
->xim_styles
);
11589 #endif /* USE_XIM */
11592 #endif /* not HAVE_X11R6_XIM */
11596 /* Calculate the absolute position in frame F
11597 from its current recorded position values and gravity. */
11600 x_calc_absolute_position (f
)
11604 int win_x
= 0, win_y
= 0;
11605 int flags
= f
->output_data
.x
->size_hint_flags
;
11608 /* We have nothing to do if the current position
11609 is already for the top-left corner. */
11610 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
11613 #ifdef USE_X_TOOLKIT
11614 this_window
= XtWindow (f
->output_data
.x
->widget
);
11616 this_window
= FRAME_X_WINDOW (f
);
11619 /* Find the position of the outside upper-left corner of
11620 the inner window, with respect to the outer window.
11621 But do this only if we will need the results. */
11622 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
11627 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
11630 x_clear_errors (FRAME_X_DISPLAY (f
));
11631 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
11633 /* From-window, to-window. */
11635 f
->output_data
.x
->parent_desc
,
11637 /* From-position, to-position. */
11638 0, 0, &win_x
, &win_y
,
11640 /* Child of win. */
11642 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
11644 Window newroot
, newparent
= 0xdeadbeef;
11645 Window
*newchildren
;
11646 unsigned int nchildren
;
11648 if (! XQueryTree (FRAME_X_DISPLAY (f
), this_window
, &newroot
,
11649 &newparent
, &newchildren
, &nchildren
))
11652 XFree ((char *) newchildren
);
11654 f
->output_data
.x
->parent_desc
= newparent
;
11660 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
11664 /* Treat negative positions as relative to the leftmost bottommost
11665 position that fits on the screen. */
11666 if (flags
& XNegative
)
11667 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
11668 - 2 * f
->output_data
.x
->border_width
- win_x
11670 + f
->output_data
.x
->left_pos
);
11672 if (flags
& YNegative
)
11674 int menubar_height
= 0;
11676 #ifdef USE_X_TOOLKIT
11677 if (f
->output_data
.x
->menubar_widget
)
11679 = (f
->output_data
.x
->menubar_widget
->core
.height
11680 + f
->output_data
.x
->menubar_widget
->core
.border_width
);
11683 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
11684 - 2 * f
->output_data
.x
->border_width
11688 + f
->output_data
.x
->top_pos
);
11691 /* The left_pos and top_pos
11692 are now relative to the top and left screen edges,
11693 so the flags should correspond. */
11694 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
11697 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
11698 to really change the position, and 0 when calling from
11699 x_make_frame_visible (in that case, XOFF and YOFF are the current
11700 position values). It is -1 when calling from x_set_frame_parameters,
11701 which means, do adjust for borders but don't change the gravity. */
11704 x_set_offset (f
, xoff
, yoff
, change_gravity
)
11706 register int xoff
, yoff
;
11707 int change_gravity
;
11709 int modified_top
, modified_left
;
11711 if (change_gravity
> 0)
11713 f
->output_data
.x
->top_pos
= yoff
;
11714 f
->output_data
.x
->left_pos
= xoff
;
11715 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
11717 f
->output_data
.x
->size_hint_flags
|= XNegative
;
11719 f
->output_data
.x
->size_hint_flags
|= YNegative
;
11720 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11722 x_calc_absolute_position (f
);
11725 x_wm_set_size_hint (f
, (long) 0, 0);
11727 modified_left
= f
->output_data
.x
->left_pos
;
11728 modified_top
= f
->output_data
.x
->top_pos
;
11729 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
11730 this seems to be unnecessary and incorrect. rms, 4/17/97. */
11731 /* It is a mystery why we need to add the border_width here
11732 when the frame is already visible, but experiment says we do. */
11733 if (change_gravity
!= 0)
11735 modified_left
+= f
->output_data
.x
->border_width
;
11736 modified_top
+= f
->output_data
.x
->border_width
;
11740 #ifdef USE_X_TOOLKIT
11741 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
11742 modified_left
, modified_top
);
11743 #else /* not USE_X_TOOLKIT */
11744 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11745 modified_left
, modified_top
);
11746 #endif /* not USE_X_TOOLKIT */
11750 /* Call this to change the size of frame F's x-window.
11751 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
11752 for this size change and subsequent size changes.
11753 Otherwise we leave the window gravity unchanged. */
11756 x_set_window_size (f
, change_gravity
, cols
, rows
)
11758 int change_gravity
;
11761 #ifndef USE_X_TOOLKIT
11762 int pixelwidth
, pixelheight
;
11767 #ifdef USE_X_TOOLKIT
11769 /* The x and y position of the widget is clobbered by the
11770 call to XtSetValues within EmacsFrameSetCharSize.
11771 This is a real kludge, but I don't understand Xt so I can't
11772 figure out a correct fix. Can anyone else tell me? -- rms. */
11773 int xpos
= f
->output_data
.x
->widget
->core
.x
;
11774 int ypos
= f
->output_data
.x
->widget
->core
.y
;
11775 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
11776 f
->output_data
.x
->widget
->core
.x
= xpos
;
11777 f
->output_data
.x
->widget
->core
.y
= ypos
;
11780 #else /* not USE_X_TOOLKIT */
11782 check_frame_size (f
, &rows
, &cols
);
11783 f
->output_data
.x
->vertical_scroll_bar_extra
11784 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
11786 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
11787 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
11788 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
11789 f
->output_data
.x
->flags_areas_extra
11790 = FRAME_FLAGS_AREA_WIDTH (f
);
11791 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
11792 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
11794 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11795 x_wm_set_size_hint (f
, (long) 0, 0);
11797 XSync (FRAME_X_DISPLAY (f
), False
);
11798 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11799 pixelwidth
, pixelheight
);
11801 /* Now, strictly speaking, we can't be sure that this is accurate,
11802 but the window manager will get around to dealing with the size
11803 change request eventually, and we'll hear how it went when the
11804 ConfigureNotify event gets here.
11806 We could just not bother storing any of this information here,
11807 and let the ConfigureNotify event set everything up, but that
11808 might be kind of confusing to the Lisp code, since size changes
11809 wouldn't be reported in the frame parameters until some random
11810 point in the future when the ConfigureNotify event arrives.
11812 We pass 1 for DELAY since we can't run Lisp code inside of
11814 change_frame_size (f
, rows
, cols
, 0, 1, 0);
11815 PIXEL_WIDTH (f
) = pixelwidth
;
11816 PIXEL_HEIGHT (f
) = pixelheight
;
11818 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
11819 receive in the ConfigureNotify event; if we get what we asked
11820 for, then the event won't cause the screen to become garbaged, so
11821 we have to make sure to do it here. */
11822 SET_FRAME_GARBAGED (f
);
11824 XFlush (FRAME_X_DISPLAY (f
));
11826 #endif /* not USE_X_TOOLKIT */
11828 /* If cursor was outside the new size, mark it as off. */
11829 mark_window_cursors_off (XWINDOW (f
->root_window
));
11831 /* Clear out any recollection of where the mouse highlighting was,
11832 since it might be in a place that's outside the new frame size.
11833 Actually checking whether it is outside is a pain in the neck,
11834 so don't try--just let the highlighting be done afresh with new size. */
11835 cancel_mouse_face (f
);
11840 /* Mouse warping. */
11843 x_set_mouse_position (f
, x
, y
)
11849 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
11850 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
11852 if (pix_x
< 0) pix_x
= 0;
11853 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
11855 if (pix_y
< 0) pix_y
= 0;
11856 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
11860 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
11861 0, 0, 0, 0, pix_x
, pix_y
);
11865 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
11868 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
11874 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
11875 0, 0, 0, 0, pix_x
, pix_y
);
11879 /* focus shifting, raising and lowering. */
11882 x_focus_on_frame (f
)
11885 #if 0 /* This proves to be unpleasant. */
11889 /* I don't think that the ICCCM allows programs to do things like this
11890 without the interaction of the window manager. Whatever you end up
11891 doing with this code, do it to x_unfocus_frame too. */
11892 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11893 RevertToPointerRoot
, CurrentTime
);
11898 x_unfocus_frame (f
)
11902 /* Look at the remarks in x_focus_on_frame. */
11903 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
11904 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
11905 RevertToPointerRoot
, CurrentTime
);
11909 /* Raise frame F. */
11915 if (f
->async_visible
)
11918 #ifdef USE_X_TOOLKIT
11919 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
11920 #else /* not USE_X_TOOLKIT */
11921 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11922 #endif /* not USE_X_TOOLKIT */
11923 XFlush (FRAME_X_DISPLAY (f
));
11928 /* Lower frame F. */
11934 if (f
->async_visible
)
11937 #ifdef USE_X_TOOLKIT
11938 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
11939 #else /* not USE_X_TOOLKIT */
11940 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11941 #endif /* not USE_X_TOOLKIT */
11942 XFlush (FRAME_X_DISPLAY (f
));
11948 XTframe_raise_lower (f
, raise_flag
)
11958 /* Change of visibility. */
11960 /* This tries to wait until the frame is really visible.
11961 However, if the window manager asks the user where to position
11962 the frame, this will return before the user finishes doing that.
11963 The frame will not actually be visible at that time,
11964 but it will become visible later when the window manager
11965 finishes with it. */
11968 x_make_frame_visible (f
)
11972 int original_top
, original_left
;
11973 int retry_count
= 2;
11979 type
= x_icon_type (f
);
11981 x_bitmap_icon (f
, type
);
11983 if (! FRAME_VISIBLE_P (f
))
11985 /* We test FRAME_GARBAGED_P here to make sure we don't
11986 call x_set_offset a second time
11987 if we get to x_make_frame_visible a second time
11988 before the window gets really visible. */
11989 if (! FRAME_ICONIFIED_P (f
)
11990 && ! f
->output_data
.x
->asked_for_visible
)
11991 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
11993 f
->output_data
.x
->asked_for_visible
= 1;
11995 if (! EQ (Vx_no_window_manager
, Qt
))
11996 x_wm_set_window_state (f
, NormalState
);
11997 #ifdef USE_X_TOOLKIT
11998 /* This was XtPopup, but that did nothing for an iconified frame. */
11999 XtMapWidget (f
->output_data
.x
->widget
);
12000 #else /* not USE_X_TOOLKIT */
12001 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12002 #endif /* not USE_X_TOOLKIT */
12003 #if 0 /* This seems to bring back scroll bars in the wrong places
12004 if the window configuration has changed. They seem
12005 to come back ok without this. */
12006 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
12007 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12011 XFlush (FRAME_X_DISPLAY (f
));
12013 /* Synchronize to ensure Emacs knows the frame is visible
12014 before we do anything else. We do this loop with input not blocked
12015 so that incoming events are handled. */
12019 /* This must be before UNBLOCK_INPUT
12020 since events that arrive in response to the actions above
12021 will set it when they are handled. */
12022 int previously_visible
= f
->output_data
.x
->has_been_visible
;
12024 original_left
= f
->output_data
.x
->left_pos
;
12025 original_top
= f
->output_data
.x
->top_pos
;
12027 /* This must come after we set COUNT. */
12030 /* We unblock here so that arriving X events are processed. */
12032 /* Now move the window back to where it was "supposed to be".
12033 But don't do it if the gravity is negative.
12034 When the gravity is negative, this uses a position
12035 that is 3 pixels too low. Perhaps that's really the border width.
12037 Don't do this if the window has never been visible before,
12038 because the window manager may choose the position
12039 and we don't want to override it. */
12041 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
12042 && f
->output_data
.x
->win_gravity
== NorthWestGravity
12043 && previously_visible
)
12047 unsigned int width
, height
, border
, depth
;
12051 /* On some window managers (such as FVWM) moving an existing
12052 window, even to the same place, causes the window manager
12053 to introduce an offset. This can cause the window to move
12054 to an unexpected location. Check the geometry (a little
12055 slow here) and then verify that the window is in the right
12056 place. If the window is not in the right place, move it
12057 there, and take the potential window manager hit. */
12058 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
12059 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
12061 if (original_left
!= x
|| original_top
!= y
)
12062 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
12063 original_left
, original_top
);
12068 XSETFRAME (frame
, f
);
12070 /* Wait until the frame is visible. Process X events until a
12071 MapNotify event has been seen, or until we think we won't get a
12072 MapNotify at all.. */
12073 for (count
= input_signal_count
+ 10;
12074 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
12076 /* Force processing of queued events. */
12079 /* Machines that do polling rather than SIGIO have been
12080 observed to go into a busy-wait here. So we'll fake an
12081 alarm signal to let the handler know that there's something
12082 to be read. We used to raise a real alarm, but it seems
12083 that the handler isn't always enabled here. This is
12085 if (input_polling_used ())
12087 /* It could be confusing if a real alarm arrives while
12088 processing the fake one. Turn it off and let the
12089 handler reset it. */
12090 extern void poll_for_input_1
P_ ((void));
12091 int old_poll_suppress_count
= poll_suppress_count
;
12092 poll_suppress_count
= 1;
12093 poll_for_input_1 ();
12094 poll_suppress_count
= old_poll_suppress_count
;
12097 /* See if a MapNotify event has been processed. */
12098 FRAME_SAMPLE_VISIBILITY (f
);
12103 (let ((f (selected-frame)))
12107 the frame is not raised with various window managers on
12108 FreeBSD, Linux and Solaris. It turns out that, for some
12109 unknown reason, the call to XtMapWidget is completely ignored.
12110 Mapping the widget a second time works. */
12112 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
12117 /* Change from mapped state to withdrawn state. */
12119 /* Make the frame visible (mapped and not iconified). */
12122 x_make_frame_invisible (f
)
12127 #ifdef USE_X_TOOLKIT
12128 /* Use the frame's outermost window, not the one we normally draw on. */
12129 window
= XtWindow (f
->output_data
.x
->widget
);
12130 #else /* not USE_X_TOOLKIT */
12131 window
= FRAME_X_WINDOW (f
);
12132 #endif /* not USE_X_TOOLKIT */
12134 /* Don't keep the highlight on an invisible frame. */
12135 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
12136 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
12138 #if 0/* This might add unreliability; I don't trust it -- rms. */
12139 if (! f
->async_visible
&& ! f
->async_iconified
)
12145 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
12146 that the current position of the window is user-specified, rather than
12147 program-specified, so that when the window is mapped again, it will be
12148 placed at the same location, without forcing the user to position it
12149 by hand again (they have already done that once for this window.) */
12150 x_wm_set_size_hint (f
, (long) 0, 1);
12154 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
12155 DefaultScreen (FRAME_X_DISPLAY (f
))))
12157 UNBLOCK_INPUT_RESIGNAL
;
12158 error ("Can't notify window manager of window withdrawal");
12160 #else /* ! defined (HAVE_X11R4) */
12162 /* Tell the window manager what we're going to do. */
12163 if (! EQ (Vx_no_window_manager
, Qt
))
12167 unmap
.xunmap
.type
= UnmapNotify
;
12168 unmap
.xunmap
.window
= window
;
12169 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
12170 unmap
.xunmap
.from_configure
= False
;
12171 if (! XSendEvent (FRAME_X_DISPLAY (f
),
12172 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
12174 SubstructureRedirectMaskSubstructureNotifyMask
,
12177 UNBLOCK_INPUT_RESIGNAL
;
12178 error ("Can't notify window manager of withdrawal");
12182 /* Unmap the window ourselves. Cheeky! */
12183 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
12184 #endif /* ! defined (HAVE_X11R4) */
12186 /* We can't distinguish this from iconification
12187 just by the event that we get from the server.
12188 So we can't win using the usual strategy of letting
12189 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
12190 and synchronize with the server to make sure we agree. */
12192 FRAME_ICONIFIED_P (f
) = 0;
12193 f
->async_visible
= 0;
12194 f
->async_iconified
= 0;
12201 /* Change window state from mapped to iconified. */
12204 x_iconify_frame (f
)
12210 /* Don't keep the highlight on an invisible frame. */
12211 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
12212 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
12214 if (f
->async_iconified
)
12219 FRAME_SAMPLE_VISIBILITY (f
);
12221 type
= x_icon_type (f
);
12223 x_bitmap_icon (f
, type
);
12225 #ifdef USE_X_TOOLKIT
12227 if (! FRAME_VISIBLE_P (f
))
12229 if (! EQ (Vx_no_window_manager
, Qt
))
12230 x_wm_set_window_state (f
, IconicState
);
12231 /* This was XtPopup, but that did nothing for an iconified frame. */
12232 XtMapWidget (f
->output_data
.x
->widget
);
12233 /* The server won't give us any event to indicate
12234 that an invisible frame was changed to an icon,
12235 so we have to record it here. */
12238 f
->async_iconified
= 1;
12239 f
->async_visible
= 0;
12244 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
12245 XtWindow (f
->output_data
.x
->widget
),
12246 DefaultScreen (FRAME_X_DISPLAY (f
)));
12250 error ("Can't notify window manager of iconification");
12252 f
->async_iconified
= 1;
12253 f
->async_visible
= 0;
12257 XFlush (FRAME_X_DISPLAY (f
));
12259 #else /* not USE_X_TOOLKIT */
12261 /* Make sure the X server knows where the window should be positioned,
12262 in case the user deiconifies with the window manager. */
12263 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
12264 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
12266 /* Since we don't know which revision of X we're running, we'll use both
12267 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
12269 /* X11R4: send a ClientMessage to the window manager using the
12270 WM_CHANGE_STATE type. */
12274 message
.xclient
.window
= FRAME_X_WINDOW (f
);
12275 message
.xclient
.type
= ClientMessage
;
12276 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
12277 message
.xclient
.format
= 32;
12278 message
.xclient
.data
.l
[0] = IconicState
;
12280 if (! XSendEvent (FRAME_X_DISPLAY (f
),
12281 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
12283 SubstructureRedirectMask
| SubstructureNotifyMask
,
12286 UNBLOCK_INPUT_RESIGNAL
;
12287 error ("Can't notify window manager of iconification");
12291 /* X11R3: set the initial_state field of the window manager hints to
12293 x_wm_set_window_state (f
, IconicState
);
12295 if (!FRAME_VISIBLE_P (f
))
12297 /* If the frame was withdrawn, before, we must map it. */
12298 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12301 f
->async_iconified
= 1;
12302 f
->async_visible
= 0;
12304 XFlush (FRAME_X_DISPLAY (f
));
12306 #endif /* not USE_X_TOOLKIT */
12309 /* Destroy the X window of frame F. */
12312 x_destroy_window (f
)
12315 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12319 /* If a display connection is dead, don't try sending more
12320 commands to the X server. */
12321 if (dpyinfo
->display
!= 0)
12323 if (f
->output_data
.x
->icon_desc
!= 0)
12324 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
12327 free_frame_xic (f
);
12329 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->window_desc
);
12330 #ifdef USE_X_TOOLKIT
12331 if (f
->output_data
.x
->widget
)
12332 XtDestroyWidget (f
->output_data
.x
->widget
);
12333 free_frame_menubar (f
);
12334 #endif /* USE_X_TOOLKIT */
12336 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
12337 unload_color (f
, f
->output_data
.x
->background_pixel
);
12338 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
12339 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
12340 unload_color (f
, f
->output_data
.x
->border_pixel
);
12341 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
12342 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
12343 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
12344 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
12345 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
12346 if (f
->output_data
.x
->white_relief
.allocated_p
)
12347 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
12348 if (f
->output_data
.x
->black_relief
.allocated_p
)
12349 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
12351 free_frame_faces (f
);
12352 XFlush (FRAME_X_DISPLAY (f
));
12355 if (f
->output_data
.x
->saved_menu_event
)
12356 xfree (f
->output_data
.x
->saved_menu_event
);
12358 xfree (f
->output_data
.x
);
12359 f
->output_data
.x
= 0;
12360 if (f
== dpyinfo
->x_focus_frame
)
12361 dpyinfo
->x_focus_frame
= 0;
12362 if (f
== dpyinfo
->x_focus_event_frame
)
12363 dpyinfo
->x_focus_event_frame
= 0;
12364 if (f
== dpyinfo
->x_highlight_frame
)
12365 dpyinfo
->x_highlight_frame
= 0;
12367 dpyinfo
->reference_count
--;
12369 if (f
== dpyinfo
->mouse_face_mouse_frame
)
12371 dpyinfo
->mouse_face_beg_row
12372 = dpyinfo
->mouse_face_beg_col
= -1;
12373 dpyinfo
->mouse_face_end_row
12374 = dpyinfo
->mouse_face_end_col
= -1;
12375 dpyinfo
->mouse_face_window
= Qnil
;
12376 dpyinfo
->mouse_face_deferred_gc
= 0;
12377 dpyinfo
->mouse_face_mouse_frame
= 0;
12383 /* Setting window manager hints. */
12385 /* Set the normal size hints for the window manager, for frame F.
12386 FLAGS is the flags word to use--or 0 meaning preserve the flags
12387 that the window now has.
12388 If USER_POSITION is nonzero, we set the USPosition
12389 flag (this is useful when FLAGS is 0). */
12392 x_wm_set_size_hint (f
, flags
, user_position
)
12397 XSizeHints size_hints
;
12399 #ifdef USE_X_TOOLKIT
12402 Dimension widget_width
, widget_height
;
12403 Window window
= XtWindow (f
->output_data
.x
->widget
);
12404 #else /* not USE_X_TOOLKIT */
12405 Window window
= FRAME_X_WINDOW (f
);
12406 #endif /* not USE_X_TOOLKIT */
12408 /* Setting PMaxSize caused various problems. */
12409 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
12411 size_hints
.x
= f
->output_data
.x
->left_pos
;
12412 size_hints
.y
= f
->output_data
.x
->top_pos
;
12414 #ifdef USE_X_TOOLKIT
12415 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
12416 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
12417 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
12418 size_hints
.height
= widget_height
;
12419 size_hints
.width
= widget_width
;
12420 #else /* not USE_X_TOOLKIT */
12421 size_hints
.height
= PIXEL_HEIGHT (f
);
12422 size_hints
.width
= PIXEL_WIDTH (f
);
12423 #endif /* not USE_X_TOOLKIT */
12425 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
12426 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
12427 size_hints
.max_width
12428 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
12429 size_hints
.max_height
12430 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
12432 /* Calculate the base and minimum sizes.
12434 (When we use the X toolkit, we don't do it here.
12435 Instead we copy the values that the widgets are using, below.) */
12436 #ifndef USE_X_TOOLKIT
12438 int base_width
, base_height
;
12439 int min_rows
= 0, min_cols
= 0;
12441 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
12442 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
12444 check_frame_size (f
, &min_rows
, &min_cols
);
12446 /* The window manager uses the base width hints to calculate the
12447 current number of rows and columns in the frame while
12448 resizing; min_width and min_height aren't useful for this
12449 purpose, since they might not give the dimensions for a
12450 zero-row, zero-column frame.
12452 We use the base_width and base_height members if we have
12453 them; otherwise, we set the min_width and min_height members
12454 to the size for a zero x zero frame. */
12457 size_hints
.flags
|= PBaseSize
;
12458 size_hints
.base_width
= base_width
;
12459 size_hints
.base_height
= base_height
;
12460 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
12461 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
12463 size_hints
.min_width
= base_width
;
12464 size_hints
.min_height
= base_height
;
12468 /* If we don't need the old flags, we don't need the old hint at all. */
12471 size_hints
.flags
|= flags
;
12474 #endif /* not USE_X_TOOLKIT */
12477 XSizeHints hints
; /* Sometimes I hate X Windows... */
12478 long supplied_return
;
12482 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
12485 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
12488 #ifdef USE_X_TOOLKIT
12489 size_hints
.base_height
= hints
.base_height
;
12490 size_hints
.base_width
= hints
.base_width
;
12491 size_hints
.min_height
= hints
.min_height
;
12492 size_hints
.min_width
= hints
.min_width
;
12496 size_hints
.flags
|= flags
;
12501 if (hints
.flags
& PSize
)
12502 size_hints
.flags
|= PSize
;
12503 if (hints
.flags
& PPosition
)
12504 size_hints
.flags
|= PPosition
;
12505 if (hints
.flags
& USPosition
)
12506 size_hints
.flags
|= USPosition
;
12507 if (hints
.flags
& USSize
)
12508 size_hints
.flags
|= USSize
;
12512 #ifndef USE_X_TOOLKIT
12517 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
12518 size_hints
.flags
|= PWinGravity
;
12522 size_hints
.flags
&= ~ PPosition
;
12523 size_hints
.flags
|= USPosition
;
12525 #endif /* PWinGravity */
12528 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
12530 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
12534 /* Used for IconicState or NormalState */
12537 x_wm_set_window_state (f
, state
)
12541 #ifdef USE_X_TOOLKIT
12544 XtSetArg (al
[0], XtNinitialState
, state
);
12545 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
12546 #else /* not USE_X_TOOLKIT */
12547 Window window
= FRAME_X_WINDOW (f
);
12549 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
12550 f
->output_data
.x
->wm_hints
.initial_state
= state
;
12552 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12553 #endif /* not USE_X_TOOLKIT */
12557 x_wm_set_icon_pixmap (f
, pixmap_id
)
12561 Pixmap icon_pixmap
;
12563 #ifndef USE_X_TOOLKIT
12564 Window window
= FRAME_X_WINDOW (f
);
12569 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
12570 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
12574 /* It seems there is no way to turn off use of an icon pixmap.
12575 The following line does it, only if no icon has yet been created,
12576 for some window managers. But with mwm it crashes.
12577 Some people say it should clear the IconPixmapHint bit in this case,
12578 but that doesn't work, and the X consortium said it isn't the
12579 right thing at all. Since there is no way to win,
12580 best to explicitly give up. */
12582 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
12588 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
12592 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
12593 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
12596 #else /* not USE_X_TOOLKIT */
12598 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
12599 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12601 #endif /* not USE_X_TOOLKIT */
12605 x_wm_set_icon_position (f
, icon_x
, icon_y
)
12607 int icon_x
, icon_y
;
12609 #ifdef USE_X_TOOLKIT
12610 Window window
= XtWindow (f
->output_data
.x
->widget
);
12612 Window window
= FRAME_X_WINDOW (f
);
12615 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
12616 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
12617 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
12619 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12623 /***********************************************************************
12625 ***********************************************************************/
12627 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
12630 x_get_font_info (f
, font_idx
)
12634 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
12638 /* Return a list of names of available fonts matching PATTERN on frame
12639 F. If SIZE is not 0, it is the size (maximum bound width) of fonts
12640 to be listed. Frame F NULL means we have not yet created any
12641 frame on X, and consult the first display in x_display_list.
12642 MAXNAMES sets a limit on how many fonts to match. */
12645 x_list_fonts (f
, pattern
, size
, maxnames
)
12647 Lisp_Object pattern
;
12651 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
12652 Lisp_Object tem
, second_best
;
12653 Display
*dpy
= f
!= NULL
? FRAME_X_DISPLAY (f
) : x_display_list
->display
;
12654 int try_XLoadQueryFont
= 0;
12657 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
12658 if (NILP (patterns
))
12659 patterns
= Fcons (pattern
, Qnil
);
12661 if (maxnames
== 1 && !size
)
12662 /* We can return any single font matching PATTERN. */
12663 try_XLoadQueryFont
= 1;
12665 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
12668 char **names
= NULL
;
12670 pattern
= XCAR (patterns
);
12671 /* See if we cached the result for this particular query.
12672 The cache is an alist of the form:
12673 (((PATTERN . MAXNAMES) (FONTNAME . WIDTH) ...) ...)
12675 if (f
&& (tem
= XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
),
12676 key
= Fcons (pattern
, make_number (maxnames
)),
12677 !NILP (list
= Fassoc (key
, tem
))))
12679 list
= Fcdr_safe (list
);
12680 /* We have a cashed list. Don't have to get the list again. */
12684 /* At first, put PATTERN in the cache. */
12687 count
= x_catch_errors (dpy
);
12689 if (try_XLoadQueryFont
)
12692 unsigned long value
;
12694 font
= XLoadQueryFont (dpy
, XSTRING (pattern
)->data
);
12695 if (x_had_errors_p (dpy
))
12697 /* This error is perhaps due to insufficient memory on X
12698 server. Let's just ignore it. */
12700 x_clear_errors (dpy
);
12704 && XGetFontProperty (font
, XA_FONT
, &value
))
12706 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
12707 int len
= strlen (name
);
12710 /* If DXPC (a Differential X Protocol Compressor)
12711 Ver.3.7 is running, XGetAtomName will return null
12712 string. We must avoid such a name. */
12714 try_XLoadQueryFont
= 0;
12718 names
= (char **) alloca (sizeof (char *));
12719 /* Some systems only allow alloca assigned to a
12721 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
12722 bcopy (name
, names
[0], len
+ 1);
12727 try_XLoadQueryFont
= 0;
12730 XFreeFont (dpy
, font
);
12733 if (!try_XLoadQueryFont
)
12735 /* We try at least 10 fonts because XListFonts will return
12736 auto-scaled fonts at the head. */
12737 names
= XListFonts (dpy
, XSTRING (pattern
)->data
, max (maxnames
, 10),
12739 if (x_had_errors_p (dpy
))
12741 /* This error is perhaps due to insufficient memory on X
12742 server. Let's just ignore it. */
12744 x_clear_errors (dpy
);
12748 x_uncatch_errors (dpy
, count
);
12755 /* Make a list of all the fonts we got back.
12756 Store that in the font cache for the display. */
12757 for (i
= 0; i
< num_fonts
; i
++)
12760 char *p
= names
[i
];
12761 int average_width
= -1, dashes
= 0;
12763 /* Count the number of dashes in NAMES[I]. If there are
12764 14 dashes, and the field value following 12th dash
12765 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
12766 is usually too ugly to be used for editing. Let's
12772 if (dashes
== 7) /* PIXEL_SIZE field */
12774 else if (dashes
== 12) /* AVERAGE_WIDTH field */
12775 average_width
= atoi (p
);
12777 if (dashes
< 14 || average_width
!= 0)
12779 tem
= build_string (names
[i
]);
12780 if (NILP (Fassoc (tem
, list
)))
12782 if (STRINGP (Vx_pixel_size_width_font_regexp
)
12783 && ((fast_c_string_match_ignore_case
12784 (Vx_pixel_size_width_font_regexp
, names
[i
]))
12786 /* We can set the value of PIXEL_SIZE to the
12787 width of this font. */
12788 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
12790 /* For the moment, width is not known. */
12791 list
= Fcons (Fcons (tem
, Qnil
), list
);
12795 if (!try_XLoadQueryFont
)
12796 XFreeFontNames (names
);
12799 /* Now store the result in the cache. */
12801 XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
)
12802 = Fcons (Fcons (key
, list
),
12803 XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
));
12806 if (NILP (list
)) continue; /* Try the remaining alternatives. */
12808 newlist
= second_best
= Qnil
;
12809 /* Make a list of the fonts that have the right width. */
12810 for (; CONSP (list
); list
= XCDR (list
))
12816 if (!CONSP (tem
) || NILP (XCAR (tem
)))
12820 newlist
= Fcons (XCAR (tem
), newlist
);
12824 if (!INTEGERP (XCDR (tem
)))
12826 /* Since we have not yet known the size of this font, we
12827 must try slow function call XLoadQueryFont. */
12828 XFontStruct
*thisinfo
;
12831 count
= x_catch_errors (dpy
);
12832 thisinfo
= XLoadQueryFont (dpy
,
12833 XSTRING (XCAR (tem
))->data
);
12834 if (x_had_errors_p (dpy
))
12836 /* This error is perhaps due to insufficient memory on X
12837 server. Let's just ignore it. */
12839 x_clear_errors (dpy
);
12841 x_uncatch_errors (dpy
, count
);
12847 = (thisinfo
->min_bounds
.width
== 0
12849 : make_number (thisinfo
->max_bounds
.width
));
12850 XFreeFont (dpy
, thisinfo
);
12853 /* For unknown reason, the previous call of XListFont had
12854 returned a font which can't be opened. Record the size
12855 as 0 not to try to open it again. */
12856 XCDR (tem
) = make_number (0);
12859 found_size
= XINT (XCDR (tem
));
12860 if (found_size
== size
)
12861 newlist
= Fcons (XCAR (tem
), newlist
);
12862 else if (found_size
> 0)
12864 if (NILP (second_best
))
12866 else if (found_size
< size
)
12868 if (XINT (XCDR (second_best
)) > size
12869 || XINT (XCDR (second_best
)) < found_size
)
12874 if (XINT (XCDR (second_best
)) > size
12875 && XINT (XCDR (second_best
)) > found_size
)
12880 if (!NILP (newlist
))
12882 else if (!NILP (second_best
))
12884 newlist
= Fcons (XCAR (second_best
), Qnil
);
12895 /* Check that FONT is valid on frame F. It is if it can be found in F's
12899 x_check_font (f
, font
)
12904 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12906 xassert (font
!= NULL
);
12908 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12909 if (dpyinfo
->font_table
[i
].name
12910 && font
== dpyinfo
->font_table
[i
].font
)
12913 xassert (i
< dpyinfo
->n_fonts
);
12916 #endif /* GLYPH_DEBUG != 0 */
12918 /* Set *W to the minimum width, *H to the minimum font height of FONT.
12919 Note: There are (broken) X fonts out there with invalid XFontStruct
12920 min_bounds contents. For example, handa@etl.go.jp reports that
12921 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
12922 have font->min_bounds.width == 0. */
12925 x_font_min_bounds (font
, w
, h
)
12929 *h
= FONT_HEIGHT (font
);
12930 *w
= font
->min_bounds
.width
;
12932 /* Try to handle the case where FONT->min_bounds has invalid
12933 contents. Since the only font known to have invalid min_bounds
12934 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
12936 *w
= font
->max_bounds
.width
;
12940 /* Compute the smallest character width and smallest font height over
12941 all fonts available on frame F. Set the members smallest_char_width
12942 and smallest_font_height in F's x_display_info structure to
12943 the values computed. Value is non-zero if smallest_font_height or
12944 smallest_char_width become smaller than they were before. */
12947 x_compute_min_glyph_bounds (f
)
12951 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12953 int old_width
= dpyinfo
->smallest_char_width
;
12954 int old_height
= dpyinfo
->smallest_font_height
;
12956 dpyinfo
->smallest_font_height
= 100000;
12957 dpyinfo
->smallest_char_width
= 100000;
12959 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
12960 if (dpyinfo
->font_table
[i
].name
)
12962 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
12965 font
= (XFontStruct
*) fontp
->font
;
12966 xassert (font
!= (XFontStruct
*) ~0);
12967 x_font_min_bounds (font
, &w
, &h
);
12969 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
12970 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
12973 xassert (dpyinfo
->smallest_char_width
> 0
12974 && dpyinfo
->smallest_font_height
> 0);
12976 return (dpyinfo
->n_fonts
== 1
12977 || dpyinfo
->smallest_char_width
< old_width
12978 || dpyinfo
->smallest_font_height
< old_height
);
12982 /* Load font named FONTNAME of the size SIZE for frame F, and return a
12983 pointer to the structure font_info while allocating it dynamically.
12984 If SIZE is 0, load any size of font.
12985 If loading is failed, return NULL. */
12988 x_load_font (f
, fontname
, size
)
12990 register char *fontname
;
12993 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12994 Lisp_Object font_names
;
12997 /* Get a list of all the fonts that match this name. Once we
12998 have a list of matching fonts, we compare them against the fonts
12999 we already have by comparing names. */
13000 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
13002 if (!NILP (font_names
))
13007 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
13008 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
13009 if (dpyinfo
->font_table
[i
].name
13010 && (!strcmp (dpyinfo
->font_table
[i
].name
,
13011 XSTRING (XCAR (tail
))->data
)
13012 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
13013 XSTRING (XCAR (tail
))->data
)))
13014 return (dpyinfo
->font_table
+ i
);
13017 /* Load the font and add it to the table. */
13021 struct font_info
*fontp
;
13022 unsigned long value
;
13025 /* If we have found fonts by x_list_font, load one of them. If
13026 not, we still try to load a font by the name given as FONTNAME
13027 because XListFonts (called in x_list_font) of some X server has
13028 a bug of not finding a font even if the font surely exists and
13029 is loadable by XLoadQueryFont. */
13030 if (size
> 0 && !NILP (font_names
))
13031 fontname
= (char *) XSTRING (XCAR (font_names
))->data
;
13034 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
13035 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
13036 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
13038 /* This error is perhaps due to insufficient memory on X
13039 server. Let's just ignore it. */
13041 x_clear_errors (FRAME_X_DISPLAY (f
));
13043 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
13048 /* Find a free slot in the font table. */
13049 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
13050 if (dpyinfo
->font_table
[i
].name
== NULL
)
13053 /* If no free slot found, maybe enlarge the font table. */
13054 if (i
== dpyinfo
->n_fonts
13055 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
13058 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
13059 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
13060 dpyinfo
->font_table
13061 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
13064 fontp
= dpyinfo
->font_table
+ i
;
13065 if (i
== dpyinfo
->n_fonts
)
13066 ++dpyinfo
->n_fonts
;
13068 /* Now fill in the slots of *FONTP. */
13070 fontp
->font
= font
;
13071 fontp
->font_idx
= i
;
13072 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
13073 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
13075 /* Try to get the full name of FONT. Put it in FULL_NAME. */
13077 if (XGetFontProperty (font
, XA_FONT
, &value
))
13079 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
13083 /* Count the number of dashes in the "full name".
13084 If it is too few, this isn't really the font's full name,
13086 In X11R4, the fonts did not come with their canonical names
13097 full_name
= (char *) xmalloc (p
- name
+ 1);
13098 bcopy (name
, full_name
, p
- name
+ 1);
13104 if (full_name
!= 0)
13105 fontp
->full_name
= full_name
;
13107 fontp
->full_name
= fontp
->name
;
13109 fontp
->size
= font
->max_bounds
.width
;
13110 fontp
->height
= FONT_HEIGHT (font
);
13112 /* For some font, ascent and descent in max_bounds field is
13113 larger than the above value. */
13114 int max_height
= font
->max_bounds
.ascent
+ font
->max_bounds
.descent
;
13115 if (max_height
> fontp
->height
)
13116 fontp
->height
= max_height
;
13119 if (NILP (font_names
))
13121 /* We come here because of a bug of XListFonts mentioned at
13122 the head of this block. Let's store this information in
13123 the cache for x_list_fonts. */
13124 Lisp_Object lispy_name
= build_string (fontname
);
13125 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
13127 XCDR (dpyinfo
->name_list_element
)
13128 = Fcons (Fcons (Fcons (lispy_name
, make_number (256)),
13129 Fcons (Fcons (lispy_full_name
,
13130 make_number (fontp
->size
)),
13132 XCDR (dpyinfo
->name_list_element
));
13134 XCDR (dpyinfo
->name_list_element
)
13135 = Fcons (Fcons (Fcons (lispy_full_name
, make_number (256)),
13136 Fcons (Fcons (lispy_full_name
,
13137 make_number (fontp
->size
)),
13139 XCDR (dpyinfo
->name_list_element
));
13142 /* The slot `encoding' specifies how to map a character
13143 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
13144 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
13145 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
13146 2:0xA020..0xFF7F). For the moment, we don't know which charset
13147 uses this font. So, we set information in fontp->encoding[1]
13148 which is never used by any charset. If mapping can't be
13149 decided, set FONT_ENCODING_NOT_DECIDED. */
13151 = (font
->max_byte1
== 0
13153 ? (font
->min_char_or_byte2
< 0x80
13154 ? (font
->max_char_or_byte2
< 0x80
13155 ? 0 /* 0x20..0x7F */
13156 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
13157 : 1) /* 0xA0..0xFF */
13159 : (font
->min_byte1
< 0x80
13160 ? (font
->max_byte1
< 0x80
13161 ? (font
->min_char_or_byte2
< 0x80
13162 ? (font
->max_char_or_byte2
< 0x80
13163 ? 0 /* 0x2020..0x7F7F */
13164 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
13165 : 3) /* 0x20A0..0x7FFF */
13166 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
13167 : (font
->min_char_or_byte2
< 0x80
13168 ? (font
->max_char_or_byte2
< 0x80
13169 ? 2 /* 0xA020..0xFF7F */
13170 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
13171 : 1))); /* 0xA0A0..0xFFFF */
13173 fontp
->baseline_offset
13174 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
13175 ? (long) value
: 0);
13176 fontp
->relative_compose
13177 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
13178 ? (long) value
: 0);
13179 fontp
->default_ascent
13180 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
13181 ? (long) value
: 0);
13183 /* Set global flag fonts_changed_p to non-zero if the font loaded
13184 has a character with a smaller width than any other character
13185 before, or if the font loaded has a smalle>r height than any
13186 other font loaded before. If this happens, it will make a
13187 glyph matrix reallocation necessary. */
13188 fonts_changed_p
= x_compute_min_glyph_bounds (f
);
13195 /* Return a pointer to struct font_info of a font named FONTNAME for
13196 frame F. If no such font is loaded, return NULL. */
13199 x_query_font (f
, fontname
)
13201 register char *fontname
;
13203 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13206 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
13207 if (dpyinfo
->font_table
[i
].name
13208 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
13209 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
13210 return (dpyinfo
->font_table
+ i
);
13215 /* Find a CCL program for a font specified by FONTP, and set the member
13216 `encoder' of the structure. */
13219 x_find_ccl_program (fontp
)
13220 struct font_info
*fontp
;
13222 Lisp_Object list
, elt
;
13225 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
13229 && STRINGP (XCAR (elt
))
13230 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
13232 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
13239 struct ccl_program
*ccl
13240 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
13242 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
13245 fontp
->font_encoder
= ccl
;
13251 /***********************************************************************
13253 ***********************************************************************/
13255 #ifdef USE_X_TOOLKIT
13256 static XrmOptionDescRec emacs_options
[] = {
13257 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
13258 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
13260 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
13261 XrmoptionSepArg
, NULL
},
13262 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
13264 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13265 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13266 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13267 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
13268 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
13269 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
13270 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
13272 #endif /* USE_X_TOOLKIT */
13274 static int x_initialized
;
13276 #ifdef MULTI_KBOARD
13277 /* Test whether two display-name strings agree up to the dot that separates
13278 the screen number from the server number. */
13280 same_x_server (name1
, name2
)
13281 char *name1
, *name2
;
13283 int seen_colon
= 0;
13284 unsigned char *system_name
= XSTRING (Vsystem_name
)->data
;
13285 int system_name_length
= strlen (system_name
);
13286 int length_until_period
= 0;
13288 while (system_name
[length_until_period
] != 0
13289 && system_name
[length_until_period
] != '.')
13290 length_until_period
++;
13292 /* Treat `unix' like an empty host name. */
13293 if (! strncmp (name1
, "unix:", 5))
13295 if (! strncmp (name2
, "unix:", 5))
13297 /* Treat this host's name like an empty host name. */
13298 if (! strncmp (name1
, system_name
, system_name_length
)
13299 && name1
[system_name_length
] == ':')
13300 name1
+= system_name_length
;
13301 if (! strncmp (name2
, system_name
, system_name_length
)
13302 && name2
[system_name_length
] == ':')
13303 name2
+= system_name_length
;
13304 /* Treat this host's domainless name like an empty host name. */
13305 if (! strncmp (name1
, system_name
, length_until_period
)
13306 && name1
[length_until_period
] == ':')
13307 name1
+= length_until_period
;
13308 if (! strncmp (name2
, system_name
, length_until_period
)
13309 && name2
[length_until_period
] == ':')
13310 name2
+= length_until_period
;
13312 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
13316 if (seen_colon
&& *name1
== '.')
13320 && (*name1
== '.' || *name1
== '\0')
13321 && (*name2
== '.' || *name2
== '\0'));
13325 struct x_display_info
*
13326 x_term_init (display_name
, xrm_option
, resource_name
)
13327 Lisp_Object display_name
;
13329 char *resource_name
;
13333 struct x_display_info
*dpyinfo
;
13338 if (!x_initialized
)
13344 #ifdef USE_X_TOOLKIT
13345 /* weiner@footloose.sps.mot.com reports that this causes
13347 X protocol error: BadAtom (invalid Atom parameter)
13348 on protocol request 18skiloaf.
13349 So let's not use it until R6. */
13350 #ifdef HAVE_X11XTR6
13351 XtSetLanguageProc (NULL
, NULL
, NULL
);
13362 argv
[argc
++] = "-xrm";
13363 argv
[argc
++] = xrm_option
;
13365 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
13366 resource_name
, EMACS_CLASS
,
13367 emacs_options
, XtNumber (emacs_options
),
13370 #ifdef HAVE_X11XTR6
13371 /* I think this is to compensate for XtSetLanguageProc. */
13376 #else /* not USE_X_TOOLKIT */
13378 XSetLocaleModifiers ("");
13380 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
13381 #endif /* not USE_X_TOOLKIT */
13383 /* Detect failure. */
13390 /* We have definitely succeeded. Record the new connection. */
13392 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
13393 bzero (dpyinfo
, sizeof *dpyinfo
);
13395 #ifdef MULTI_KBOARD
13397 struct x_display_info
*share
;
13400 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
13401 share
= share
->next
, tail
= XCDR (tail
))
13402 if (same_x_server (XSTRING (XCAR (XCAR (tail
)))->data
,
13403 XSTRING (display_name
)->data
))
13406 dpyinfo
->kboard
= share
->kboard
;
13409 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
13410 init_kboard (dpyinfo
->kboard
);
13411 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
13413 char *vendor
= ServerVendor (dpy
);
13415 dpyinfo
->kboard
->Vsystem_key_alist
13416 = call1 (Qvendor_specific_keysyms
,
13417 build_string (vendor
? vendor
: ""));
13421 dpyinfo
->kboard
->next_kboard
= all_kboards
;
13422 all_kboards
= dpyinfo
->kboard
;
13423 /* Don't let the initial kboard remain current longer than necessary.
13424 That would cause problems if a file loaded on startup tries to
13425 prompt in the mini-buffer. */
13426 if (current_kboard
== initial_kboard
)
13427 current_kboard
= dpyinfo
->kboard
;
13429 dpyinfo
->kboard
->reference_count
++;
13433 /* Put this display on the chain. */
13434 dpyinfo
->next
= x_display_list
;
13435 x_display_list
= dpyinfo
;
13437 /* Put it on x_display_name_list as well, to keep them parallel. */
13438 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
13439 x_display_name_list
);
13440 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
13442 dpyinfo
->display
= dpy
;
13445 XSetAfterFunction (x_current_display
, x_trace_wire
);
13449 = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name
))
13450 + STRING_BYTES (XSTRING (Vsystem_name
))
13452 sprintf (dpyinfo
->x_id_name
, "%s@%s",
13453 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
13455 /* Figure out which modifier bits mean what. */
13456 x_find_modifier_meanings (dpyinfo
);
13458 /* Get the scroll bar cursor. */
13459 dpyinfo
->vertical_scroll_bar_cursor
13460 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
13462 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
13463 resource_name
, EMACS_CLASS
);
13464 #ifdef HAVE_XRMSETDATABASE
13465 XrmSetDatabase (dpyinfo
->display
, xrdb
);
13467 dpyinfo
->display
->db
= xrdb
;
13469 /* Put the rdb where we can find it in a way that works on
13471 dpyinfo
->xrdb
= xrdb
;
13473 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
13474 DefaultScreen (dpyinfo
->display
));
13475 select_visual (dpyinfo
);
13476 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
13477 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
13478 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
13479 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
13480 dpyinfo
->grabbed
= 0;
13481 dpyinfo
->reference_count
= 0;
13482 dpyinfo
->icon_bitmap_id
= -1;
13483 dpyinfo
->font_table
= NULL
;
13484 dpyinfo
->n_fonts
= 0;
13485 dpyinfo
->font_table_size
= 0;
13486 dpyinfo
->bitmaps
= 0;
13487 dpyinfo
->bitmaps_size
= 0;
13488 dpyinfo
->bitmaps_last
= 0;
13489 dpyinfo
->scratch_cursor_gc
= 0;
13490 dpyinfo
->mouse_face_mouse_frame
= 0;
13491 dpyinfo
->mouse_face_deferred_gc
= 0;
13492 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
13493 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
13494 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
13495 dpyinfo
->mouse_face_window
= Qnil
;
13496 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
13497 dpyinfo
->mouse_face_defer
= 0;
13498 dpyinfo
->x_focus_frame
= 0;
13499 dpyinfo
->x_focus_event_frame
= 0;
13500 dpyinfo
->x_highlight_frame
= 0;
13501 dpyinfo
->image_cache
= make_image_cache ();
13503 /* See if a private colormap is requested. */
13504 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
13506 if (dpyinfo
->visual
->class == PseudoColor
)
13509 value
= display_x_get_resource (dpyinfo
,
13510 build_string ("privateColormap"),
13511 build_string ("PrivateColormap"),
13513 if (STRINGP (value
)
13514 && (!strcmp (XSTRING (value
)->data
, "true")
13515 || !strcmp (XSTRING (value
)->data
, "on")))
13516 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
13520 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
13521 dpyinfo
->visual
, AllocNone
);
13524 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
13525 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
13526 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
13527 dpyinfo
->resy
= pixels
* 25.4 / mm
;
13528 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
13529 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
13530 dpyinfo
->resx
= pixels
* 25.4 / mm
;
13533 dpyinfo
->Xatom_wm_protocols
13534 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
13535 dpyinfo
->Xatom_wm_take_focus
13536 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
13537 dpyinfo
->Xatom_wm_save_yourself
13538 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
13539 dpyinfo
->Xatom_wm_delete_window
13540 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
13541 dpyinfo
->Xatom_wm_change_state
13542 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
13543 dpyinfo
->Xatom_wm_configure_denied
13544 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
13545 dpyinfo
->Xatom_wm_window_moved
13546 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
13547 dpyinfo
->Xatom_editres
13548 = XInternAtom (dpyinfo
->display
, "Editres", False
);
13549 dpyinfo
->Xatom_CLIPBOARD
13550 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
13551 dpyinfo
->Xatom_TIMESTAMP
13552 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
13553 dpyinfo
->Xatom_TEXT
13554 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
13555 dpyinfo
->Xatom_COMPOUND_TEXT
13556 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
13557 dpyinfo
->Xatom_DELETE
13558 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
13559 dpyinfo
->Xatom_MULTIPLE
13560 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
13561 dpyinfo
->Xatom_INCR
13562 = XInternAtom (dpyinfo
->display
, "INCR", False
);
13563 dpyinfo
->Xatom_EMACS_TMP
13564 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
13565 dpyinfo
->Xatom_TARGETS
13566 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
13567 dpyinfo
->Xatom_NULL
13568 = XInternAtom (dpyinfo
->display
, "NULL", False
);
13569 dpyinfo
->Xatom_ATOM_PAIR
13570 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
13571 /* For properties of font. */
13572 dpyinfo
->Xatom_PIXEL_SIZE
13573 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
13574 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
13575 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
13576 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
13577 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
13578 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
13579 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
13581 /* Ghostscript support. */
13582 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
13583 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
13585 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
13588 dpyinfo
->cut_buffers_initialized
= 0;
13590 connection
= ConnectionNumber (dpyinfo
->display
);
13591 dpyinfo
->connection
= connection
;
13596 null_bits
[0] = 0x00;
13598 dpyinfo
->null_pixel
13599 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
13600 null_bits
, 1, 1, (long) 0, (long) 0,
13605 extern int gray_bitmap_width
, gray_bitmap_height
;
13606 extern unsigned char *gray_bitmap_bits
;
13608 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
13610 gray_bitmap_width
, gray_bitmap_height
,
13611 (unsigned long) 1, (unsigned long) 0, 1);
13615 xim_initialize (dpyinfo
, resource_name
);
13618 #ifdef subprocesses
13619 /* This is only needed for distinguishing keyboard and process input. */
13620 if (connection
!= 0)
13621 add_keyboard_wait_descriptor (connection
);
13624 #ifndef F_SETOWN_BUG
13626 #ifdef F_SETOWN_SOCK_NEG
13627 /* stdin is a socket here */
13628 fcntl (connection
, F_SETOWN
, -getpid ());
13629 #else /* ! defined (F_SETOWN_SOCK_NEG) */
13630 fcntl (connection
, F_SETOWN
, getpid ());
13631 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
13632 #endif /* ! defined (F_SETOWN) */
13633 #endif /* F_SETOWN_BUG */
13636 if (interrupt_input
)
13637 init_sigio (connection
);
13638 #endif /* ! defined (SIGIO) */
13641 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
13642 /* Make sure that we have a valid font for dialog boxes
13643 so that Xt does not crash. */
13645 Display
*dpy
= dpyinfo
->display
;
13646 XrmValue d
, fr
, to
;
13650 d
.addr
= (XPointer
)&dpy
;
13651 d
.size
= sizeof (Display
*);
13652 fr
.addr
= XtDefaultFont
;
13653 fr
.size
= sizeof (XtDefaultFont
);
13654 to
.size
= sizeof (Font
*);
13655 to
.addr
= (XPointer
)&font
;
13656 count
= x_catch_errors (dpy
);
13657 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
13659 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
13660 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
13661 x_uncatch_errors (dpy
, count
);
13666 /* See if we should run in synchronous mode. This is useful
13667 for debugging X code. */
13670 value
= display_x_get_resource (dpyinfo
,
13671 build_string ("synchronous"),
13672 build_string ("Synchronous"),
13674 if (STRINGP (value
)
13675 && (!strcmp (XSTRING (value
)->data
, "true")
13676 || !strcmp (XSTRING (value
)->data
, "on")))
13677 XSynchronize (dpyinfo
->display
, True
);
13685 /* Get rid of display DPYINFO, assuming all frames are already gone,
13686 and without sending any more commands to the X server. */
13689 x_delete_display (dpyinfo
)
13690 struct x_display_info
*dpyinfo
;
13692 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
13694 /* Discard this display from x_display_name_list and x_display_list.
13695 We can't use Fdelq because that can quit. */
13696 if (! NILP (x_display_name_list
)
13697 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
13698 x_display_name_list
= XCDR (x_display_name_list
);
13703 tail
= x_display_name_list
;
13704 while (CONSP (tail
) && CONSP (XCDR (tail
)))
13706 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
13708 XCDR (tail
) = XCDR (XCDR (tail
));
13711 tail
= XCDR (tail
);
13715 if (next_noop_dpyinfo
== dpyinfo
)
13716 next_noop_dpyinfo
= dpyinfo
->next
;
13718 if (x_display_list
== dpyinfo
)
13719 x_display_list
= dpyinfo
->next
;
13722 struct x_display_info
*tail
;
13724 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
13725 if (tail
->next
== dpyinfo
)
13726 tail
->next
= tail
->next
->next
;
13729 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
13730 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
13731 XrmDestroyDatabase (dpyinfo
->xrdb
);
13734 #ifdef MULTI_KBOARD
13735 if (--dpyinfo
->kboard
->reference_count
== 0)
13736 delete_kboard (dpyinfo
->kboard
);
13740 xim_close_dpy (dpyinfo
);
13743 xfree (dpyinfo
->font_table
);
13744 xfree (dpyinfo
->x_id_name
);
13745 xfree (dpyinfo
->color_cells
);
13750 /* Set up use of X before we make the first connection. */
13752 static struct redisplay_interface x_redisplay_interface
=
13757 x_clear_end_of_line
,
13759 x_after_update_window_line
,
13760 x_update_window_begin
,
13761 x_update_window_end
,
13764 x_clear_mouse_face
,
13765 x_get_glyph_overhangs
,
13766 x_fix_overlapping_area
13772 rif
= &x_redisplay_interface
;
13774 clear_frame_hook
= x_clear_frame
;
13775 ins_del_lines_hook
= x_ins_del_lines
;
13776 change_line_highlight_hook
= x_change_line_highlight
;
13777 delete_glyphs_hook
= x_delete_glyphs
;
13778 ring_bell_hook
= XTring_bell
;
13779 reset_terminal_modes_hook
= XTreset_terminal_modes
;
13780 set_terminal_modes_hook
= XTset_terminal_modes
;
13781 update_begin_hook
= x_update_begin
;
13782 update_end_hook
= x_update_end
;
13783 set_terminal_window_hook
= XTset_terminal_window
;
13784 read_socket_hook
= XTread_socket
;
13785 frame_up_to_date_hook
= XTframe_up_to_date
;
13786 reassert_line_highlight_hook
= XTreassert_line_highlight
;
13787 mouse_position_hook
= XTmouse_position
;
13788 frame_rehighlight_hook
= XTframe_rehighlight
;
13789 frame_raise_lower_hook
= XTframe_raise_lower
;
13790 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
13791 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
13792 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
13793 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
13794 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
13796 scroll_region_ok
= 1; /* we'll scroll partial frames */
13797 char_ins_del_ok
= 0; /* just as fast to write the line */
13798 line_ins_del_ok
= 1; /* we'll just blt 'em */
13799 fast_clear_end_of_line
= 1; /* X does this well */
13800 memory_below_frame
= 0; /* we don't remember what scrolls
13805 last_tool_bar_item
= -1;
13806 any_help_event_p
= 0;
13808 /* Try to use interrupt input; if we can't, then start polling. */
13809 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
13811 #ifdef USE_X_TOOLKIT
13812 XtToolkitInitialize ();
13813 Xt_app_con
= XtCreateApplicationContext ();
13814 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
13816 /* Install an asynchronous timer that processes Xt timeout events
13817 every 0.1s. This is necessary because some widget sets use
13818 timeouts internally, for example the LessTif menu bar, or the
13819 Xaw3d scroll bar. When Xt timouts aren't processed, these
13820 widgets don't behave normally. */
13822 EMACS_TIME interval
;
13823 EMACS_SET_SECS_USECS (interval
, 0, 100000);
13824 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
13828 #if USE_TOOLKIT_SCROLL_BARS
13829 xaw3d_arrow_scroll
= False
;
13830 xaw3d_pick_top
= True
;
13833 /* Note that there is no real way portable across R3/R4 to get the
13834 original error handler. */
13835 XSetErrorHandler (x_error_handler
);
13836 XSetIOErrorHandler (x_io_error_quitter
);
13838 /* Disable Window Change signals; they are handled by X events. */
13840 signal (SIGWINCH
, SIG_DFL
);
13841 #endif /* ! defined (SIGWINCH) */
13843 signal (SIGPIPE
, x_connection_signal
);
13850 staticpro (&x_error_message_string
);
13851 x_error_message_string
= Qnil
;
13853 staticpro (&x_display_name_list
);
13854 x_display_name_list
= Qnil
;
13856 staticpro (&last_mouse_scroll_bar
);
13857 last_mouse_scroll_bar
= Qnil
;
13859 staticpro (&Qvendor_specific_keysyms
);
13860 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
13862 staticpro (&last_mouse_press_frame
);
13863 last_mouse_press_frame
= Qnil
;
13866 staticpro (&help_echo
);
13867 help_echo_object
= Qnil
;
13868 staticpro (&help_echo_object
);
13869 help_echo_window
= Qnil
;
13870 staticpro (&help_echo_window
);
13871 previous_help_echo
= Qnil
;
13872 staticpro (&previous_help_echo
);
13873 help_echo_pos
= -1;
13875 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
13876 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
13877 For example, if a block cursor is over a tab, it will be drawn as\n\
13878 wide as that tab on the display.");
13879 x_stretch_cursor_p
= 0;
13881 DEFVAR_BOOL ("x-toolkit-scroll-bars-p", &x_toolkit_scroll_bars_p
,
13882 "If not nil, Emacs uses toolkit scroll bars.");
13883 #if USE_TOOLKIT_SCROLL_BARS
13884 x_toolkit_scroll_bars_p
= 1;
13886 x_toolkit_scroll_bars_p
= 0;
13889 staticpro (&last_mouse_motion_frame
);
13890 last_mouse_motion_frame
= Qnil
;
13893 #endif /* not HAVE_X_WINDOWS */