1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000, 2001
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 #else /* !USE_MOTIF i.e. use Xaw */
123 #include <X11/Xaw3d/Simple.h>
124 #include <X11/Xaw3d/Scrollbar.h>
125 #define ARROW_SCROLLBAR
126 #include <X11/Xaw3d/ScrollbarP.h>
127 #else /* !HAVE_XAW3D */
128 #include <X11/Xaw/Simple.h>
129 #include <X11/Xaw/Scrollbar.h>
130 #endif /* !HAVE_XAW3D */
132 #define XtNpickTop "pickTop"
133 #endif /* !XtNpickTop */
134 #endif /* !USE_MOTIF */
135 #endif /* USE_TOOLKIT_SCROLL_BARS */
137 #endif /* USE_X_TOOLKIT */
139 #ifndef USE_X_TOOLKIT
140 #define x_any_window_to_frame x_window_to_frame
141 #define x_top_window_to_frame x_window_to_frame
146 #ifndef XtNinitialState
147 #define XtNinitialState "initialState"
152 #define min(a,b) ((a) < (b) ? (a) : (b))
155 #define max(a,b) ((a) > (b) ? (a) : (b))
158 #define abs(x) ((x) < 0 ? -(x) : (x))
160 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
163 /* Bitmaps for truncated lines. */
168 LEFT_TRUNCATION_BITMAP
,
169 RIGHT_TRUNCATION_BITMAP
,
170 OVERLAY_ARROW_BITMAP
,
171 CONTINUED_LINE_BITMAP
,
172 CONTINUATION_LINE_BITMAP
,
176 /* Bitmap drawn to indicate lines not displaying text if
177 `indicate-empty-lines' is non-nil. */
181 static unsigned char zv_bits
[] = {
182 0x00, 0x00, 0x1e, 0x1e, 0x1e, 0x1e, 0x00, 0x00};
184 /* An arrow like this: `<-'. */
187 #define left_height 8
188 static unsigned char left_bits
[] = {
189 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
191 /* Right truncation arrow bitmap `->'. */
193 #define right_width 8
194 #define right_height 8
195 static unsigned char right_bits
[] = {
196 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
198 /* Marker for continued lines. */
200 #define continued_width 8
201 #define continued_height 8
202 static unsigned char continued_bits
[] = {
203 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
205 /* Marker for continuation lines. */
207 #define continuation_width 8
208 #define continuation_height 8
209 static unsigned char continuation_bits
[] = {
210 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
212 /* Overlay arrow bitmap. */
218 static unsigned char ov_bits
[] = {
219 0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
221 /* A triangular arrow. */
224 static unsigned char ov_bits
[] = {
225 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
229 extern Lisp_Object Qhelp_echo
;
232 /* Non-nil means Emacs uses toolkit scroll bars. */
234 Lisp_Object Vx_toolkit_scroll_bars
;
236 /* If a string, XTread_socket generates an event to display that string.
237 (The display is done in read_char.) */
239 static Lisp_Object help_echo
;
240 static Lisp_Object help_echo_window
;
241 static Lisp_Object help_echo_object
;
242 static int help_echo_pos
;
244 /* Temporary variable for XTread_socket. */
246 static Lisp_Object previous_help_echo
;
248 /* Non-zero means that a HELP_EVENT has been generated since Emacs
251 static int any_help_event_p
;
253 /* Non-zero means draw block and hollow cursor as wide as the glyph
254 under it. For example, if a block cursor is over a tab, it will be
255 drawn as wide as that tab on the display. */
257 int x_stretch_cursor_p
;
259 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
261 int x_use_underline_position_properties
;
263 /* This is a chain of structures for all the X displays currently in
266 struct x_display_info
*x_display_list
;
268 /* This is a list of cons cells, each of the form (NAME
269 . FONT-LIST-CACHE), one for each element of x_display_list and in
270 the same order. NAME is the name of the frame. FONT-LIST-CACHE
271 records previous values returned by x-list-fonts. */
273 Lisp_Object x_display_name_list
;
275 /* Frame being updated by update_frame. This is declared in term.c.
276 This is set by update_begin and looked at by all the XT functions.
277 It is zero while not inside an update. In that case, the XT
278 functions assume that `selected_frame' is the frame to apply to. */
280 extern struct frame
*updating_frame
;
282 extern int waiting_for_input
;
284 /* This is a frame waiting to be auto-raised, within XTread_socket. */
286 struct frame
*pending_autoraise_frame
;
289 /* The application context for Xt use. */
290 XtAppContext Xt_app_con
;
291 static String Xt_default_resources
[] = {0};
292 #endif /* USE_X_TOOLKIT */
294 /* Nominal cursor position -- where to draw output.
295 HPOS and VPOS are window relative glyph matrix coordinates.
296 X and Y are window relative pixel coordinates. */
298 struct cursor_pos output_cursor
;
300 /* Non-zero means user is interacting with a toolkit scroll bar. */
302 static int toolkit_scroll_bar_interaction
;
306 Formerly, we used PointerMotionHintMask (in standard_event_mask)
307 so that we would have to call XQueryPointer after each MotionNotify
308 event to ask for another such event. However, this made mouse tracking
309 slow, and there was a bug that made it eventually stop.
311 Simply asking for MotionNotify all the time seems to work better.
313 In order to avoid asking for motion events and then throwing most
314 of them away or busy-polling the server for mouse positions, we ask
315 the server for pointer motion hints. This means that we get only
316 one event per group of mouse movements. "Groups" are delimited by
317 other kinds of events (focus changes and button clicks, for
318 example), or by XQueryPointer calls; when one of these happens, we
319 get another MotionNotify event the next time the mouse moves. This
320 is at least as efficient as getting motion events when mouse
321 tracking is on, and I suspect only negligibly worse when tracking
324 /* Where the mouse was last time we reported a mouse event. */
326 FRAME_PTR last_mouse_frame
;
327 static XRectangle last_mouse_glyph
;
328 static Lisp_Object last_mouse_press_frame
;
330 /* The scroll bar in which the last X motion event occurred.
332 If the last X motion event occurred in a scroll bar, we set this so
333 XTmouse_position can know whether to report a scroll bar motion or
336 If the last X motion event didn't occur in a scroll bar, we set
337 this to Qnil, to tell XTmouse_position to return an ordinary motion
340 static Lisp_Object last_mouse_scroll_bar
;
342 /* This is a hack. We would really prefer that XTmouse_position would
343 return the time associated with the position it returns, but there
344 doesn't seem to be any way to wrest the time-stamp from the server
345 along with the position query. So, we just keep track of the time
346 of the last movement we received, and return that in hopes that
347 it's somewhat accurate. */
349 static Time last_mouse_movement_time
;
351 /* Incremented by XTread_socket whenever it really tries to read
355 static int volatile input_signal_count
;
357 static int input_signal_count
;
360 /* Used locally within XTread_socket. */
362 static int x_noop_count
;
364 /* Initial values of argv and argc. */
366 extern char **initial_argv
;
367 extern int initial_argc
;
369 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
371 /* Tells if a window manager is present or not. */
373 extern Lisp_Object Vx_no_window_manager
;
375 extern Lisp_Object Qface
, Qmouse_face
;
379 /* A mask of extra modifier bits to put into every keyboard char. */
381 extern int extra_keyboard_modifiers
;
383 static Lisp_Object Qvendor_specific_keysyms
;
385 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
386 extern Lisp_Object x_icon_type
P_ ((struct frame
*));
389 /* Enumeration for overriding/changing the face to use for drawing
390 glyphs in x_draw_glyphs. */
392 enum draw_glyphs_face
402 static int cursor_in_mouse_face_p
P_ ((struct window
*));
403 static int clear_mouse_face
P_ ((struct x_display_info
*));
404 static int x_alloc_nearest_color_1
P_ ((Display
*, Colormap
, XColor
*));
405 static void x_set_window_size_1
P_ ((struct frame
*, int, int, int));
406 static const XColor
*x_color_cells
P_ ((Display
*, int *));
407 static void x_update_window_end
P_ ((struct window
*, int, int));
408 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
409 void x_delete_display
P_ ((struct x_display_info
*));
410 static unsigned int x_x_to_emacs_modifiers
P_ ((struct x_display_info
*,
412 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
414 static int fast_find_string_pos
P_ ((struct window
*, int, Lisp_Object
,
415 int *, int *, int *, int *, int));
416 static void set_output_cursor
P_ ((struct cursor_pos
*));
417 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
418 int *, int *, int *, int));
419 static void note_mode_line_highlight
P_ ((struct window
*, int, int));
420 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
421 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
422 static void x_handle_tool_bar_click
P_ ((struct frame
*, XButtonEvent
*));
423 static void show_mouse_face
P_ ((struct x_display_info
*,
424 enum draw_glyphs_face
));
425 static int x_io_error_quitter
P_ ((Display
*));
426 int x_catch_errors
P_ ((Display
*));
427 void x_uncatch_errors
P_ ((Display
*, int));
428 void x_lower_frame
P_ ((struct frame
*));
429 void x_scroll_bar_clear
P_ ((struct frame
*));
430 int x_had_errors_p
P_ ((Display
*));
431 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
432 void x_raise_frame
P_ ((struct frame
*));
433 void x_set_window_size
P_ ((struct frame
*, int, int, int));
434 void x_wm_set_window_state
P_ ((struct frame
*, int));
435 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
436 void x_initialize
P_ ((void));
437 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
438 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
439 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
441 enum draw_glyphs_face
));
442 static void x_update_end
P_ ((struct frame
*));
443 static void XTframe_up_to_date
P_ ((struct frame
*));
444 static void XTreassert_line_highlight
P_ ((int, int));
445 static void x_change_line_highlight
P_ ((int, int, int, int));
446 static void XTset_terminal_modes
P_ ((void));
447 static void XTreset_terminal_modes
P_ ((void));
448 static void XTcursor_to
P_ ((int, int, int, int));
449 static void x_write_glyphs
P_ ((struct glyph
*, int));
450 static void x_clear_end_of_line
P_ ((int));
451 static void x_clear_frame
P_ ((void));
452 static void x_clear_cursor
P_ ((struct window
*));
453 static void frame_highlight
P_ ((struct frame
*));
454 static void frame_unhighlight
P_ ((struct frame
*));
455 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
456 static void XTframe_rehighlight
P_ ((struct frame
*));
457 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
458 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
459 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int));
460 static int x_intersect_rectangles
P_ ((XRectangle
*, XRectangle
*,
462 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
463 static int expose_window_tree
P_ ((struct window
*, XRectangle
*));
464 static int expose_window
P_ ((struct window
*, XRectangle
*));
465 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
466 XRectangle
*, enum glyph_row_area
));
467 static int expose_line
P_ ((struct window
*, struct glyph_row
*,
469 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
470 static void x_update_window_cursor
P_ ((struct window
*, int));
471 static void x_erase_phys_cursor
P_ ((struct window
*));
472 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
473 static void x_draw_bitmap
P_ ((struct window
*, struct glyph_row
*,
476 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
478 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, XRectangle
*));
479 static void x_draw_row_bitmaps
P_ ((struct window
*, struct glyph_row
*));
480 static void note_overwritten_text_cursor
P_ ((struct window
*, int, int));
481 static void x_flush
P_ ((struct frame
*f
));
482 static void x_update_begin
P_ ((struct frame
*));
483 static void x_update_window_begin
P_ ((struct window
*));
484 static void x_draw_vertical_border
P_ ((struct window
*));
485 static void x_after_update_window_line
P_ ((struct glyph_row
*));
486 static INLINE
void take_vertical_position_into_account
P_ ((struct it
*));
487 static void x_produce_stretch_glyph
P_ ((struct it
*));
488 static struct scroll_bar
*x_window_to_scroll_bar
P_ ((Window
));
489 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
490 enum scroll_bar_part
*,
491 Lisp_Object
*, Lisp_Object
*,
494 /* Flush display of frame F, or of all frames if F is null. */
503 Lisp_Object rest
, frame
;
504 FOR_EACH_FRAME (rest
, frame
)
505 x_flush (XFRAME (frame
));
507 else if (FRAME_X_P (f
))
508 XFlush (FRAME_X_DISPLAY (f
));
513 /* Remove calls to XFlush by defining XFlush to an empty replacement.
514 Calls to XFlush should be unnecessary because the X output buffer
515 is flushed automatically as needed by calls to XPending,
516 XNextEvent, or XWindowEvent according to the XFlush man page.
517 XTread_socket calls XPending. Removing XFlush improves
520 #define XFlush(DISPLAY) (void) 0
523 /***********************************************************************
525 ***********************************************************************/
529 /* This is a function useful for recording debugging information about
530 the sequence of occurrences in this file. */
538 struct record event_record
[100];
540 int event_record_index
;
542 record_event (locus
, type
)
546 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
547 event_record_index
= 0;
549 event_record
[event_record_index
].locus
= locus
;
550 event_record
[event_record_index
].type
= type
;
551 event_record_index
++;
558 /* Return the struct x_display_info corresponding to DPY. */
560 struct x_display_info
*
561 x_display_info_for_display (dpy
)
564 struct x_display_info
*dpyinfo
;
566 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
567 if (dpyinfo
->display
== dpy
)
575 /***********************************************************************
576 Starting and ending an update
577 ***********************************************************************/
579 /* Start an update of frame F. This function is installed as a hook
580 for update_begin, i.e. it is called when update_begin is called.
581 This function is called prior to calls to x_update_window_begin for
582 each window being updated. Currently, there is nothing to do here
583 because all interesting stuff is done on a window basis. */
593 /* Start update of window W. Set the global variable updated_window
594 to the window being updated and set output_cursor to the cursor
598 x_update_window_begin (w
)
601 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
602 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
605 set_output_cursor (&w
->cursor
);
609 if (f
== display_info
->mouse_face_mouse_frame
)
611 /* Don't do highlighting for mouse motion during the update. */
612 display_info
->mouse_face_defer
= 1;
614 /* If F needs to be redrawn, simply forget about any prior mouse
616 if (FRAME_GARBAGED_P (f
))
617 display_info
->mouse_face_window
= Qnil
;
619 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
620 their mouse_face_p flag set, which means that they are always
621 unequal to rows in a desired matrix which never have that
622 flag set. So, rows containing mouse-face glyphs are never
623 scrolled, and we don't have to switch the mouse highlight off
624 here to prevent it from being scrolled. */
626 /* Can we tell that this update does not affect the window
627 where the mouse highlight is? If so, no need to turn off.
628 Likewise, don't do anything if the frame is garbaged;
629 in that case, the frame's current matrix that we would use
630 is all wrong, and we will redisplay that line anyway. */
631 if (!NILP (display_info
->mouse_face_window
)
632 && w
== XWINDOW (display_info
->mouse_face_window
))
636 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
637 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
640 if (i
< w
->desired_matrix
->nrows
)
641 clear_mouse_face (display_info
);
650 /* Draw a vertical window border to the right of window W if W doesn't
651 have vertical scroll bars. */
654 x_draw_vertical_border (w
)
657 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
659 /* Redraw borders between horizontally adjacent windows. Don't
660 do it for frames with vertical scroll bars because either the
661 right scroll bar of a window, or the left scroll bar of its
662 neighbor will suffice as a border. */
663 if (!WINDOW_RIGHTMOST_P (w
)
664 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
668 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
669 x1
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
);
672 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
673 f
->output_data
.x
->normal_gc
, x1
, y0
, x1
, y1
);
678 /* End update of window W (which is equal to updated_window).
680 Draw vertical borders between horizontally adjacent windows, and
681 display W's cursor if CURSOR_ON_P is non-zero.
683 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
684 glyphs in mouse-face were overwritten. In that case we have to
685 make sure that the mouse-highlight is properly redrawn.
687 W may be a menu bar pseudo-window in case we don't have X toolkit
688 support. Such windows don't have a cursor, so don't display it
692 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
694 int cursor_on_p
, mouse_face_overwritten_p
;
696 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
698 if (!w
->pseudo_window_p
)
703 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
705 output_cursor
.x
, output_cursor
.y
);
707 x_draw_vertical_border (w
);
711 /* If a row with mouse-face was overwritten, arrange for
712 XTframe_up_to_date to redisplay the mouse highlight. */
713 if (mouse_face_overwritten_p
)
715 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
716 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
717 dpyinfo
->mouse_face_window
= Qnil
;
720 updated_window
= NULL
;
724 /* End update of frame F. This function is installed as a hook in
731 /* Mouse highlight may be displayed again. */
732 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
735 XFlush (FRAME_X_DISPLAY (f
));
740 /* This function is called from various places in xdisp.c whenever a
741 complete update has been performed. The global variable
742 updated_window is not available here. */
745 XTframe_up_to_date (f
)
750 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
752 if (dpyinfo
->mouse_face_deferred_gc
753 || f
== dpyinfo
->mouse_face_mouse_frame
)
756 if (dpyinfo
->mouse_face_mouse_frame
)
757 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
758 dpyinfo
->mouse_face_mouse_x
,
759 dpyinfo
->mouse_face_mouse_y
);
760 dpyinfo
->mouse_face_deferred_gc
= 0;
767 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
768 arrow bitmaps, or clear the areas where they would be displayed
769 before DESIRED_ROW is made current. The window being updated is
770 found in updated_window. This function It is called from
771 update_window_line only if it is known that there are differences
772 between bitmaps to be drawn between current row and DESIRED_ROW. */
775 x_after_update_window_line (desired_row
)
776 struct glyph_row
*desired_row
;
778 struct window
*w
= updated_window
;
782 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
788 x_draw_row_bitmaps (w
, desired_row
);
790 /* When a window has disappeared, make sure that no rest of
791 full-width rows stays visible in the internal border. */
792 if (windows_or_buffers_changed
793 && (f
= XFRAME (w
->frame
),
794 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
797 int height
= desired_row
->visible_height
;
798 int x
= (window_box_right (w
, -1)
799 + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
));
800 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
802 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
803 x
, y
, width
, height
, False
);
811 /* Draw the bitmap WHICH in one of the areas to the left or right of
812 window W. ROW is the glyph row for which to display the bitmap; it
813 determines the vertical position at which the bitmap has to be
817 x_draw_bitmap (w
, row
, which
)
819 struct glyph_row
*row
;
820 enum bitmap_type which
;
822 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
823 Display
*display
= FRAME_X_DISPLAY (f
);
824 Window window
= FRAME_X_WINDOW (f
);
828 GC gc
= f
->output_data
.x
->normal_gc
;
830 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
832 /* Must clip because of partially visible lines. */
833 x_clip_to_row (w
, row
, gc
, 1);
837 case LEFT_TRUNCATION_BITMAP
:
841 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
843 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
846 case OVERLAY_ARROW_BITMAP
:
850 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
852 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
855 case RIGHT_TRUNCATION_BITMAP
:
859 x
= window_box_right (w
, -1);
860 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
863 case CONTINUED_LINE_BITMAP
:
866 bits
= continued_bits
;
867 x
= window_box_right (w
, -1);
868 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
871 case CONTINUATION_LINE_BITMAP
:
872 wd
= continuation_width
;
873 h
= continuation_height
;
874 bits
= continuation_bits
;
875 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
877 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
884 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
886 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
893 /* Convert to frame coordinates. Set dy to the offset in the row to
894 start drawing the bitmap. */
895 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
896 dy
= (row
->height
- h
) / 2;
898 /* Draw the bitmap. I believe these small pixmaps can be cached
900 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
901 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, wd
, h
,
903 face
->background
, depth
);
904 XCopyArea (display
, pixmap
, window
, gc
, 0, 0, wd
, h
, x
, y
+ dy
);
905 XFreePixmap (display
, pixmap
);
906 XSetClipMask (display
, gc
, None
);
910 /* Draw flags bitmaps for glyph row ROW on window W. Call this
911 function with input blocked. */
914 x_draw_row_bitmaps (w
, row
)
916 struct glyph_row
*row
;
918 struct frame
*f
= XFRAME (w
->frame
);
919 enum bitmap_type bitmap
;
921 int header_line_height
= -1;
923 xassert (interrupt_input_blocked
);
925 /* If row is completely invisible, because of vscrolling, we
926 don't have to draw anything. */
927 if (row
->visible_height
<= 0)
930 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
931 PREPARE_FACE_FOR_DISPLAY (f
, face
);
933 /* Decide which bitmap to draw at the left side. */
934 if (row
->overlay_arrow_p
)
935 bitmap
= OVERLAY_ARROW_BITMAP
;
936 else if (row
->truncated_on_left_p
)
937 bitmap
= LEFT_TRUNCATION_BITMAP
;
938 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
939 bitmap
= CONTINUATION_LINE_BITMAP
;
940 else if (row
->indicate_empty_line_p
)
941 bitmap
= ZV_LINE_BITMAP
;
945 /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
947 if (bitmap
== NO_BITMAP
948 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
949 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
951 /* If W has a vertical border to its left, don't draw over it. */
952 int border
= ((XFASTINT (w
->left
) > 0
953 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
955 int left
= window_box_left (w
, -1);
957 if (header_line_height
< 0)
958 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
960 /* In case the same realized face is used for bitmap areas and
961 for something displayed in the text (e.g. face `region' on
962 mono-displays, the fill style may have been changed to
963 FillSolid in x_draw_glyph_string_background. */
965 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
967 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
969 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
972 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
974 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
976 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - border
,
977 row
->visible_height
);
979 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
982 /* Draw the left bitmap. */
983 if (bitmap
!= NO_BITMAP
)
984 x_draw_bitmap (w
, row
, bitmap
);
986 /* Decide which bitmap to draw at the right side. */
987 if (row
->truncated_on_right_p
)
988 bitmap
= RIGHT_TRUNCATION_BITMAP
;
989 else if (row
->continued_p
)
990 bitmap
= CONTINUED_LINE_BITMAP
;
994 /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
996 if (bitmap
== NO_BITMAP
997 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
)
998 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
1000 int right
= window_box_right (w
, -1);
1002 if (header_line_height
< 0)
1003 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1005 /* In case the same realized face is used for bitmap areas and
1006 for something displayed in the text (e.g. face `region' on
1007 mono-displays, the fill style may have been changed to
1008 FillSolid in x_draw_glyph_string_background. */
1010 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
1012 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
1013 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1016 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
1018 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
),
1019 row
->visible_height
);
1021 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
1024 /* Draw the right bitmap. */
1025 if (bitmap
!= NO_BITMAP
)
1026 x_draw_bitmap (w
, row
, bitmap
);
1030 /***********************************************************************
1032 ***********************************************************************/
1034 /* External interface to control of standout mode. Not used for X
1035 frames. Aborts when called. */
1038 XTreassert_line_highlight (new, vpos
)
1045 /* Call this when about to modify line at position VPOS and change
1046 whether it is highlighted. Not used for X frames. Aborts when
1050 x_change_line_highlight (new_highlight
, vpos
, y
, first_unused_hpos
)
1051 int new_highlight
, vpos
, y
, first_unused_hpos
;
1057 /* This is called when starting Emacs and when restarting after
1058 suspend. When starting Emacs, no X window is mapped. And nothing
1059 must be done to Emacs's own window if it is suspended (though that
1063 XTset_terminal_modes ()
1067 /* This is called when exiting or suspending Emacs. Exiting will make
1068 the X-windows go away, and suspending requires no action. */
1071 XTreset_terminal_modes ()
1077 /***********************************************************************
1079 ***********************************************************************/
1081 /* Set the global variable output_cursor to CURSOR. All cursor
1082 positions are relative to updated_window. */
1085 set_output_cursor (cursor
)
1086 struct cursor_pos
*cursor
;
1088 output_cursor
.hpos
= cursor
->hpos
;
1089 output_cursor
.vpos
= cursor
->vpos
;
1090 output_cursor
.x
= cursor
->x
;
1091 output_cursor
.y
= cursor
->y
;
1095 /* Set a nominal cursor position.
1097 HPOS and VPOS are column/row positions in a window glyph matrix. X
1098 and Y are window text area relative pixel positions.
1100 If this is done during an update, updated_window will contain the
1101 window that is being updated and the position is the future output
1102 cursor position for that window. If updated_window is null, use
1103 selected_window and display the cursor at the given position. */
1106 XTcursor_to (vpos
, hpos
, y
, x
)
1107 int vpos
, hpos
, y
, x
;
1111 /* If updated_window is not set, work on selected_window. */
1115 w
= XWINDOW (selected_window
);
1117 /* Set the output cursor. */
1118 output_cursor
.hpos
= hpos
;
1119 output_cursor
.vpos
= vpos
;
1120 output_cursor
.x
= x
;
1121 output_cursor
.y
= y
;
1123 /* If not called as part of an update, really display the cursor.
1124 This will also set the cursor position of W. */
1125 if (updated_window
== NULL
)
1128 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1129 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1136 /***********************************************************************
1138 ***********************************************************************/
1140 /* Function prototypes of this page. */
1142 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1146 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1147 int, XChar2b
*, int));
1148 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
1149 static void x_encode_char
P_ ((int, XChar2b
*, struct font_info
*));
1150 static void x_append_glyph
P_ ((struct it
*));
1151 static void x_append_composite_glyph
P_ ((struct it
*));
1152 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1154 static void x_produce_glyphs
P_ ((struct it
*));
1155 static void x_produce_image_glyph
P_ ((struct it
*it
));
1158 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1159 is not contained in the font. */
1161 static INLINE XCharStruct
*
1162 x_per_char_metric (font
, char2b
)
1166 /* The result metric information. */
1167 XCharStruct
*pcm
= NULL
;
1169 xassert (font
&& char2b
);
1171 if (font
->per_char
!= NULL
)
1173 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
1175 /* min_char_or_byte2 specifies the linear character index
1176 corresponding to the first element of the per_char array,
1177 max_char_or_byte2 is the index of the last character. A
1178 character with non-zero CHAR2B->byte1 is not in the font.
1179 A character with byte2 less than min_char_or_byte2 or
1180 greater max_char_or_byte2 is not in the font. */
1181 if (char2b
->byte1
== 0
1182 && char2b
->byte2
>= font
->min_char_or_byte2
1183 && char2b
->byte2
<= font
->max_char_or_byte2
)
1184 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
1188 /* If either min_byte1 or max_byte1 are nonzero, both
1189 min_char_or_byte2 and max_char_or_byte2 are less than
1190 256, and the 2-byte character index values corresponding
1191 to the per_char array element N (counting from 0) are:
1193 byte1 = N/D + min_byte1
1194 byte2 = N\D + min_char_or_byte2
1198 D = max_char_or_byte2 - min_char_or_byte2 + 1
1199 / = integer division
1200 \ = integer modulus */
1201 if (char2b
->byte1
>= font
->min_byte1
1202 && char2b
->byte1
<= font
->max_byte1
1203 && char2b
->byte2
>= font
->min_char_or_byte2
1204 && char2b
->byte2
<= font
->max_char_or_byte2
)
1206 pcm
= (font
->per_char
1207 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
1208 * (char2b
->byte1
- font
->min_byte1
))
1209 + (char2b
->byte2
- font
->min_char_or_byte2
));
1215 /* If the per_char pointer is null, all glyphs between the first
1216 and last character indexes inclusive have the same
1217 information, as given by both min_bounds and max_bounds. */
1218 if (char2b
->byte2
>= font
->min_char_or_byte2
1219 && char2b
->byte2
<= font
->max_char_or_byte2
)
1220 pcm
= &font
->max_bounds
;
1223 return ((pcm
== NULL
1224 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
1229 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1230 the two-byte form of C. Encoding is returned in *CHAR2B. */
1233 x_encode_char (c
, char2b
, font_info
)
1236 struct font_info
*font_info
;
1238 int charset
= CHAR_CHARSET (c
);
1239 XFontStruct
*font
= font_info
->font
;
1241 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1242 This may be either a program in a special encoder language or a
1244 if (font_info
->font_encoder
)
1246 /* It's a program. */
1247 struct ccl_program
*ccl
= font_info
->font_encoder
;
1249 if (CHARSET_DIMENSION (charset
) == 1)
1251 ccl
->reg
[0] = charset
;
1252 ccl
->reg
[1] = char2b
->byte2
;
1256 ccl
->reg
[0] = charset
;
1257 ccl
->reg
[1] = char2b
->byte1
;
1258 ccl
->reg
[2] = char2b
->byte2
;
1261 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1263 /* We assume that MSBs are appropriately set/reset by CCL
1265 if (font
->max_byte1
== 0) /* 1-byte font */
1266 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
1268 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
1270 else if (font_info
->encoding
[charset
])
1272 /* Fixed encoding scheme. See fontset.h for the meaning of the
1273 encoding numbers. */
1274 int enc
= font_info
->encoding
[charset
];
1276 if ((enc
== 1 || enc
== 2)
1277 && CHARSET_DIMENSION (charset
) == 2)
1278 char2b
->byte1
|= 0x80;
1280 if (enc
== 1 || enc
== 3)
1281 char2b
->byte2
|= 0x80;
1286 /* Get face and two-byte form of character C in face FACE_ID on frame
1287 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1288 means we want to display multibyte text. Value is a pointer to a
1289 realized face that is ready for display. */
1291 static INLINE
struct face
*
1292 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
)
1298 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1302 /* Unibyte case. We don't have to encode, but we have to make
1303 sure to use a face suitable for unibyte. */
1306 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1307 face
= FACE_FROM_ID (f
, face_id
);
1309 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1311 /* Case of ASCII in a face known to fit ASCII. */
1317 int c1
, c2
, charset
;
1319 /* Split characters into bytes. If c2 is -1 afterwards, C is
1320 really a one-byte character so that byte1 is zero. */
1321 SPLIT_CHAR (c
, charset
, c1
, c2
);
1323 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1325 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1327 /* Maybe encode the character in *CHAR2B. */
1328 if (face
->font
!= NULL
)
1330 struct font_info
*font_info
1331 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1333 x_encode_char (c
, char2b
, font_info
);
1337 /* Make sure X resources of the face are allocated. */
1338 xassert (face
!= NULL
);
1339 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1345 /* Get face and two-byte form of character glyph GLYPH on frame F.
1346 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1347 a pointer to a realized face that is ready for display. */
1349 static INLINE
struct face
*
1350 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1352 struct glyph
*glyph
;
1358 xassert (glyph
->type
== CHAR_GLYPH
);
1359 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1364 if (!glyph
->multibyte_p
)
1366 /* Unibyte case. We don't have to encode, but we have to make
1367 sure to use a face suitable for unibyte. */
1369 char2b
->byte2
= glyph
->u
.ch
;
1371 else if (glyph
->u
.ch
< 128
1372 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1374 /* Case of ASCII in a face known to fit ASCII. */
1376 char2b
->byte2
= glyph
->u
.ch
;
1380 int c1
, c2
, charset
;
1382 /* Split characters into bytes. If c2 is -1 afterwards, C is
1383 really a one-byte character so that byte1 is zero. */
1384 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1386 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1388 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1390 /* Maybe encode the character in *CHAR2B. */
1391 if (charset
!= CHARSET_ASCII
)
1393 struct font_info
*font_info
1394 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1397 x_encode_char (glyph
->u
.ch
, char2b
, font_info
);
1400 = ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
1405 /* Make sure X resources of the face are allocated. */
1406 xassert (face
!= NULL
);
1407 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1412 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1413 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1419 struct glyph
*glyph
;
1420 enum glyph_row_area area
= it
->area
;
1422 xassert (it
->glyph_row
);
1423 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1425 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1426 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1428 glyph
->charpos
= CHARPOS (it
->position
);
1429 glyph
->object
= it
->object
;
1430 glyph
->pixel_width
= it
->pixel_width
;
1431 glyph
->voffset
= it
->voffset
;
1432 glyph
->type
= CHAR_GLYPH
;
1433 glyph
->multibyte_p
= it
->multibyte_p
;
1434 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1435 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1436 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1437 || it
->phys_descent
> it
->descent
);
1438 glyph
->padding_p
= 0;
1439 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1440 glyph
->face_id
= it
->face_id
;
1441 glyph
->u
.ch
= it
->char_to_display
;
1442 ++it
->glyph_row
->used
[area
];
1446 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1447 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1450 x_append_composite_glyph (it
)
1453 struct glyph
*glyph
;
1454 enum glyph_row_area area
= it
->area
;
1456 xassert (it
->glyph_row
);
1458 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1459 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1461 glyph
->charpos
= CHARPOS (it
->position
);
1462 glyph
->object
= it
->object
;
1463 glyph
->pixel_width
= it
->pixel_width
;
1464 glyph
->voffset
= it
->voffset
;
1465 glyph
->type
= COMPOSITE_GLYPH
;
1466 glyph
->multibyte_p
= it
->multibyte_p
;
1467 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1468 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1469 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1470 || it
->phys_descent
> it
->descent
);
1471 glyph
->padding_p
= 0;
1472 glyph
->glyph_not_available_p
= 0;
1473 glyph
->face_id
= it
->face_id
;
1474 glyph
->u
.cmp_id
= it
->cmp_id
;
1475 ++it
->glyph_row
->used
[area
];
1480 /* Change IT->ascent and IT->height according to the setting of
1484 take_vertical_position_into_account (it
)
1489 if (it
->voffset
< 0)
1490 /* Increase the ascent so that we can display the text higher
1492 it
->ascent
+= abs (it
->voffset
);
1494 /* Increase the descent so that we can display the text lower
1496 it
->descent
+= it
->voffset
;
1501 /* Produce glyphs/get display metrics for the image IT is loaded with.
1502 See the description of struct display_iterator in dispextern.h for
1503 an overview of struct display_iterator. */
1506 x_produce_image_glyph (it
)
1512 xassert (it
->what
== IT_IMAGE
);
1514 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1515 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1518 /* Make sure X resources of the face and image are loaded. */
1519 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1520 prepare_image_for_display (it
->f
, img
);
1522 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1523 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->vmargin
- it
->ascent
;
1524 it
->pixel_width
= img
->width
+ 2 * img
->hmargin
;
1528 if (face
->box
!= FACE_NO_BOX
)
1530 if (face
->box_line_width
> 0)
1532 it
->ascent
+= face
->box_line_width
;
1533 it
->descent
+= face
->box_line_width
;
1536 if (it
->start_of_box_run_p
)
1537 it
->pixel_width
+= abs (face
->box_line_width
);
1538 if (it
->end_of_box_run_p
)
1539 it
->pixel_width
+= abs (face
->box_line_width
);
1542 take_vertical_position_into_account (it
);
1546 struct glyph
*glyph
;
1547 enum glyph_row_area area
= it
->area
;
1549 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1550 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1552 glyph
->charpos
= CHARPOS (it
->position
);
1553 glyph
->object
= it
->object
;
1554 glyph
->pixel_width
= it
->pixel_width
;
1555 glyph
->voffset
= it
->voffset
;
1556 glyph
->type
= IMAGE_GLYPH
;
1557 glyph
->multibyte_p
= it
->multibyte_p
;
1558 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1559 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1560 glyph
->overlaps_vertically_p
= 0;
1561 glyph
->padding_p
= 0;
1562 glyph
->glyph_not_available_p
= 0;
1563 glyph
->face_id
= it
->face_id
;
1564 glyph
->u
.img_id
= img
->id
;
1565 ++it
->glyph_row
->used
[area
];
1571 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1572 of the glyph, WIDTH and HEIGHT are the width and height of the
1573 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1574 ascent of the glyph (0 <= ASCENT <= 1). */
1577 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1583 struct glyph
*glyph
;
1584 enum glyph_row_area area
= it
->area
;
1586 xassert (ascent
>= 0 && ascent
<= 1);
1588 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1589 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1591 glyph
->charpos
= CHARPOS (it
->position
);
1592 glyph
->object
= object
;
1593 glyph
->pixel_width
= width
;
1594 glyph
->voffset
= it
->voffset
;
1595 glyph
->type
= STRETCH_GLYPH
;
1596 glyph
->multibyte_p
= it
->multibyte_p
;
1597 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1598 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1599 glyph
->overlaps_vertically_p
= 0;
1600 glyph
->padding_p
= 0;
1601 glyph
->glyph_not_available_p
= 0;
1602 glyph
->face_id
= it
->face_id
;
1603 glyph
->u
.stretch
.ascent
= height
* ascent
;
1604 glyph
->u
.stretch
.height
= height
;
1605 ++it
->glyph_row
->used
[area
];
1610 /* Produce a stretch glyph for iterator IT. IT->object is the value
1611 of the glyph property displayed. The value must be a list
1612 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1615 1. `:width WIDTH' specifies that the space should be WIDTH *
1616 canonical char width wide. WIDTH may be an integer or floating
1619 2. `:relative-width FACTOR' specifies that the width of the stretch
1620 should be computed from the width of the first character having the
1621 `glyph' property, and should be FACTOR times that width.
1623 3. `:align-to HPOS' specifies that the space should be wide enough
1624 to reach HPOS, a value in canonical character units.
1626 Exactly one of the above pairs must be present.
1628 4. `:height HEIGHT' specifies that the height of the stretch produced
1629 should be HEIGHT, measured in canonical character units.
1631 5. `:relative-height FACTOR' specifies that the height of the the
1632 stretch should be FACTOR times the height of the characters having
1635 Either none or exactly one of 4 or 5 must be present.
1637 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1638 of the stretch should be used for the ascent of the stretch.
1639 ASCENT must be in the range 0 <= ASCENT <= 100. */
1642 ((INTEGERP (X) || FLOATP (X)) \
1648 x_produce_stretch_glyph (it
)
1651 /* (space :width WIDTH :height HEIGHT. */
1653 extern Lisp_Object Qspace
;
1655 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
1656 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1657 extern Lisp_Object QCalign_to
;
1658 Lisp_Object prop
, plist
;
1659 double width
= 0, height
= 0, ascent
= 0;
1660 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1661 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1663 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1665 /* List should start with `space'. */
1666 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1667 plist
= XCDR (it
->object
);
1669 /* Compute the width of the stretch. */
1670 if (prop
= Fplist_get (plist
, QCwidth
),
1672 /* Absolute width `:width WIDTH' specified and valid. */
1673 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1674 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1677 /* Relative width `:relative-width FACTOR' specified and valid.
1678 Compute the width of the characters having the `glyph'
1681 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1684 if (it
->multibyte_p
)
1686 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1687 - IT_BYTEPOS (*it
));
1688 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1691 it2
.c
= *p
, it2
.len
= 1;
1693 it2
.glyph_row
= NULL
;
1694 it2
.what
= IT_CHARACTER
;
1695 x_produce_glyphs (&it2
);
1696 width
= NUMVAL (prop
) * it2
.pixel_width
;
1698 else if (prop
= Fplist_get (plist
, QCalign_to
),
1700 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1702 /* Nothing specified -> width defaults to canonical char width. */
1703 width
= CANON_X_UNIT (it
->f
);
1705 /* Compute height. */
1706 if (prop
= Fplist_get (plist
, QCheight
),
1708 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1709 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1711 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1713 height
= FONT_HEIGHT (font
);
1715 /* Compute percentage of height used for ascent. If
1716 `:ascent ASCENT' is present and valid, use that. Otherwise,
1717 derive the ascent from the font in use. */
1718 if (prop
= Fplist_get (plist
, QCascent
),
1719 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1720 ascent
= NUMVAL (prop
) / 100.0;
1722 ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1731 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1732 if (!STRINGP (object
))
1733 object
= it
->w
->buffer
;
1734 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1737 it
->pixel_width
= width
;
1738 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1739 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1742 if (face
->box
!= FACE_NO_BOX
)
1744 if (face
->box_line_width
> 0)
1746 it
->ascent
+= face
->box_line_width
;
1747 it
->descent
+= face
->box_line_width
;
1750 if (it
->start_of_box_run_p
)
1751 it
->pixel_width
+= abs (face
->box_line_width
);
1752 if (it
->end_of_box_run_p
)
1753 it
->pixel_width
+= abs (face
->box_line_width
);
1756 take_vertical_position_into_account (it
);
1759 /* Return proper value to be used as baseline offset of font that has
1760 ASCENT and DESCENT to draw characters by the font at the vertical
1761 center of the line of frame F.
1763 Here, out task is to find the value of BOFF in the following figure;
1765 -------------------------+-----------+-
1766 -+-+---------+-+ | |
1768 | | | | F_ASCENT F_HEIGHT
1771 | | |-|-+------+-----------|------- baseline
1773 | |---------|-+-+ | |
1775 -+-+---------+-+ F_DESCENT |
1776 -------------------------+-----------+-
1778 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1779 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1780 DESCENT = FONT->descent
1781 HEIGHT = FONT_HEIGHT (FONT)
1782 F_DESCENT = (F->output_data.x->font->descent
1783 - F->output_data.x->baseline_offset)
1784 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1787 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1789 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
1790 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
1791 - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
1793 /* Produce glyphs/get display metrics for the display element IT is
1794 loaded with. See the description of struct display_iterator in
1795 dispextern.h for an overview of struct display_iterator. */
1798 x_produce_glyphs (it
)
1801 it
->glyph_not_available_p
= 0;
1803 if (it
->what
== IT_CHARACTER
)
1807 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1809 int font_not_found_p
;
1810 struct font_info
*font_info
;
1811 int boff
; /* baseline offset */
1812 /* We may change it->multibyte_p upon unibyte<->multibyte
1813 conversion. So, save the current value now and restore it
1816 Note: It seems that we don't have to record multibyte_p in
1817 struct glyph because the character code itself tells if or
1818 not the character is multibyte. Thus, in the future, we must
1819 consider eliminating the field `multibyte_p' in the struct
1821 int saved_multibyte_p
= it
->multibyte_p
;
1823 /* Maybe translate single-byte characters to multibyte, or the
1825 it
->char_to_display
= it
->c
;
1826 if (!ASCII_BYTE_P (it
->c
))
1828 if (unibyte_display_via_language_environment
1829 && SINGLE_BYTE_CHAR_P (it
->c
)
1831 || !NILP (Vnonascii_translation_table
)))
1833 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
1834 it
->multibyte_p
= 1;
1835 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1836 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1838 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
1839 && !it
->multibyte_p
)
1841 it
->multibyte_p
= 1;
1842 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1843 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1847 /* Get font to use. Encode IT->char_to_display. */
1848 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
1849 it
->face_id
, &char2b
,
1853 /* When no suitable font found, use the default font. */
1854 font_not_found_p
= font
== NULL
;
1855 if (font_not_found_p
)
1857 font
= FRAME_FONT (it
->f
);
1858 boff
= it
->f
->output_data
.x
->baseline_offset
;
1863 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
1864 boff
= font_info
->baseline_offset
;
1865 if (font_info
->vertical_centering
)
1866 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
1869 if (it
->char_to_display
>= ' '
1870 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
1872 /* Either unibyte or ASCII. */
1877 pcm
= x_per_char_metric (font
, &char2b
);
1878 it
->ascent
= font
->ascent
+ boff
;
1879 it
->descent
= font
->descent
- boff
;
1883 it
->phys_ascent
= pcm
->ascent
+ boff
;
1884 it
->phys_descent
= pcm
->descent
- boff
;
1885 it
->pixel_width
= pcm
->width
;
1889 it
->glyph_not_available_p
= 1;
1890 it
->phys_ascent
= font
->ascent
+ boff
;
1891 it
->phys_descent
= font
->descent
- boff
;
1892 it
->pixel_width
= FONT_WIDTH (font
);
1895 /* If this is a space inside a region of text with
1896 `space-width' property, change its width. */
1897 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
1899 it
->pixel_width
*= XFLOATINT (it
->space_width
);
1901 /* If face has a box, add the box thickness to the character
1902 height. If character has a box line to the left and/or
1903 right, add the box line width to the character's width. */
1904 if (face
->box
!= FACE_NO_BOX
)
1906 int thick
= face
->box_line_width
;
1910 it
->ascent
+= thick
;
1911 it
->descent
+= thick
;
1916 if (it
->start_of_box_run_p
)
1917 it
->pixel_width
+= thick
;
1918 if (it
->end_of_box_run_p
)
1919 it
->pixel_width
+= thick
;
1922 /* If face has an overline, add the height of the overline
1923 (1 pixel) and a 1 pixel margin to the character height. */
1924 if (face
->overline_p
)
1927 take_vertical_position_into_account (it
);
1929 /* If we have to actually produce glyphs, do it. */
1934 /* Translate a space with a `space-width' property
1935 into a stretch glyph. */
1936 double ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1937 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1938 it
->ascent
+ it
->descent
, ascent
);
1941 x_append_glyph (it
);
1943 /* If characters with lbearing or rbearing are displayed
1944 in this line, record that fact in a flag of the
1945 glyph row. This is used to optimize X output code. */
1946 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
1947 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1950 else if (it
->char_to_display
== '\n')
1952 /* A newline has no width but we need the height of the line. */
1953 it
->pixel_width
= 0;
1955 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1956 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1958 if (face
->box
!= FACE_NO_BOX
1959 && face
->box_line_width
> 0)
1961 it
->ascent
+= face
->box_line_width
;
1962 it
->descent
+= face
->box_line_width
;
1965 else if (it
->char_to_display
== '\t')
1967 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
1968 int x
= it
->current_x
+ it
->continuation_lines_width
;
1969 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
1971 /* If the distance from the current position to the next tab
1972 stop is less than a canonical character width, use the
1973 tab stop after that. */
1974 if (next_tab_x
- x
< CANON_X_UNIT (it
->f
))
1975 next_tab_x
+= tab_width
;
1977 it
->pixel_width
= next_tab_x
- x
;
1979 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1980 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1984 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
1985 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1986 it
->ascent
+ it
->descent
, ascent
);
1991 /* A multi-byte character. Assume that the display width of the
1992 character is the width of the character multiplied by the
1993 width of the font. */
1995 /* If we found a font, this font should give us the right
1996 metrics. If we didn't find a font, use the frame's
1997 default font and calculate the width of the character
1998 from the charset width; this is what old redisplay code
2000 pcm
= x_per_char_metric (font
, &char2b
);
2001 if (font_not_found_p
|| !pcm
)
2003 int charset
= CHAR_CHARSET (it
->char_to_display
);
2005 it
->glyph_not_available_p
= 1;
2006 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
2007 * CHARSET_WIDTH (charset
));
2008 it
->phys_ascent
= font
->ascent
+ boff
;
2009 it
->phys_descent
= font
->descent
- boff
;
2013 it
->pixel_width
= pcm
->width
;
2014 it
->phys_ascent
= pcm
->ascent
+ boff
;
2015 it
->phys_descent
= pcm
->descent
- boff
;
2017 && (pcm
->lbearing
< 0
2018 || pcm
->rbearing
> pcm
->width
))
2019 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2022 it
->ascent
= font
->ascent
+ boff
;
2023 it
->descent
= font
->descent
- boff
;
2024 if (face
->box
!= FACE_NO_BOX
)
2026 int thick
= face
->box_line_width
;
2030 it
->ascent
+= thick
;
2031 it
->descent
+= thick
;
2036 if (it
->start_of_box_run_p
)
2037 it
->pixel_width
+= thick
;
2038 if (it
->end_of_box_run_p
)
2039 it
->pixel_width
+= thick
;
2042 /* If face has an overline, add the height of the overline
2043 (1 pixel) and a 1 pixel margin to the character height. */
2044 if (face
->overline_p
)
2047 take_vertical_position_into_account (it
);
2050 x_append_glyph (it
);
2052 it
->multibyte_p
= saved_multibyte_p
;
2054 else if (it
->what
== IT_COMPOSITION
)
2056 /* Note: A composition is represented as one glyph in the
2057 glyph matrix. There are no padding glyphs. */
2060 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2062 int font_not_found_p
;
2063 struct font_info
*font_info
;
2064 int boff
; /* baseline offset */
2065 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2067 /* Maybe translate single-byte characters to multibyte. */
2068 it
->char_to_display
= it
->c
;
2069 if (unibyte_display_via_language_environment
2070 && SINGLE_BYTE_CHAR_P (it
->c
)
2073 && !NILP (Vnonascii_translation_table
))))
2075 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2078 /* Get face and font to use. Encode IT->char_to_display. */
2079 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2080 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2081 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2082 it
->face_id
, &char2b
, it
->multibyte_p
);
2085 /* When no suitable font found, use the default font. */
2086 font_not_found_p
= font
== NULL
;
2087 if (font_not_found_p
)
2089 font
= FRAME_FONT (it
->f
);
2090 boff
= it
->f
->output_data
.x
->baseline_offset
;
2095 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2096 boff
= font_info
->baseline_offset
;
2097 if (font_info
->vertical_centering
)
2098 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2101 /* There are no padding glyphs, so there is only one glyph to
2102 produce for the composition. Important is that pixel_width,
2103 ascent and descent are the values of what is drawn by
2104 draw_glyphs (i.e. the values of the overall glyphs composed). */
2107 /* If we have not yet calculated pixel size data of glyphs of
2108 the composition for the current face font, calculate them
2109 now. Theoretically, we have to check all fonts for the
2110 glyphs, but that requires much time and memory space. So,
2111 here we check only the font of the first glyph. This leads
2112 to incorrect display very rarely, and C-l (recenter) can
2113 correct the display anyway. */
2114 if (cmp
->font
!= (void *) font
)
2116 /* Ascent and descent of the font of the first character of
2117 this composition (adjusted by baseline offset). Ascent
2118 and descent of overall glyphs should not be less than
2119 them respectively. */
2120 int font_ascent
= font
->ascent
+ boff
;
2121 int font_descent
= font
->descent
- boff
;
2122 /* Bounding box of the overall glyphs. */
2123 int leftmost
, rightmost
, lowest
, highest
;
2124 int i
, width
, ascent
, descent
;
2126 cmp
->font
= (void *) font
;
2128 /* Initialize the bounding box. */
2130 && (pcm
= x_per_char_metric (font
, &char2b
)))
2133 ascent
= pcm
->ascent
;
2134 descent
= pcm
->descent
;
2138 width
= FONT_WIDTH (font
);
2139 ascent
= font
->ascent
;
2140 descent
= font
->descent
;
2144 lowest
= - descent
+ boff
;
2145 highest
= ascent
+ boff
;
2149 && font_info
->default_ascent
2150 && CHAR_TABLE_P (Vuse_default_ascent
)
2151 && !NILP (Faref (Vuse_default_ascent
,
2152 make_number (it
->char_to_display
))))
2153 highest
= font_info
->default_ascent
+ boff
;
2155 /* Draw the first glyph at the normal position. It may be
2156 shifted to right later if some other glyphs are drawn at
2158 cmp
->offsets
[0] = 0;
2159 cmp
->offsets
[1] = boff
;
2161 /* Set cmp->offsets for the remaining glyphs. */
2162 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2164 int left
, right
, btm
, top
;
2165 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2166 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2168 face
= FACE_FROM_ID (it
->f
, face_id
);
2169 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2174 font
= FRAME_FONT (it
->f
);
2175 boff
= it
->f
->output_data
.x
->baseline_offset
;
2181 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2182 boff
= font_info
->baseline_offset
;
2183 if (font_info
->vertical_centering
)
2184 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2188 && (pcm
= x_per_char_metric (font
, &char2b
)))
2191 ascent
= pcm
->ascent
;
2192 descent
= pcm
->descent
;
2196 width
= FONT_WIDTH (font
);
2201 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2203 /* Relative composition with or without
2205 left
= (leftmost
+ rightmost
- width
) / 2;
2206 btm
= - descent
+ boff
;
2207 if (font_info
&& font_info
->relative_compose
2208 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2209 || NILP (Faref (Vignore_relative_composition
,
2210 make_number (ch
)))))
2213 if (- descent
>= font_info
->relative_compose
)
2214 /* One extra pixel between two glyphs. */
2216 else if (ascent
<= 0)
2217 /* One extra pixel between two glyphs. */
2218 btm
= lowest
- 1 - ascent
- descent
;
2223 /* A composition rule is specified by an integer
2224 value that encodes global and new reference
2225 points (GREF and NREF). GREF and NREF are
2226 specified by numbers as below:
2234 ---3---4---5--- baseline
2236 6---7---8 -- descent
2238 int rule
= COMPOSITION_RULE (cmp
, i
);
2239 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2241 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2242 grefx
= gref
% 3, nrefx
= nref
% 3;
2243 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2246 + grefx
* (rightmost
- leftmost
) / 2
2247 - nrefx
* width
/ 2);
2248 btm
= ((grefy
== 0 ? highest
2250 : grefy
== 2 ? lowest
2251 : (highest
+ lowest
) / 2)
2252 - (nrefy
== 0 ? ascent
+ descent
2253 : nrefy
== 1 ? descent
- boff
2255 : (ascent
+ descent
) / 2));
2258 cmp
->offsets
[i
* 2] = left
;
2259 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2261 /* Update the bounding box of the overall glyphs. */
2262 right
= left
+ width
;
2263 top
= btm
+ descent
+ ascent
;
2264 if (left
< leftmost
)
2266 if (right
> rightmost
)
2274 /* If there are glyphs whose x-offsets are negative,
2275 shift all glyphs to the right and make all x-offsets
2279 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2280 cmp
->offsets
[i
* 2] -= leftmost
;
2281 rightmost
-= leftmost
;
2284 cmp
->pixel_width
= rightmost
;
2285 cmp
->ascent
= highest
;
2286 cmp
->descent
= - lowest
;
2287 if (cmp
->ascent
< font_ascent
)
2288 cmp
->ascent
= font_ascent
;
2289 if (cmp
->descent
< font_descent
)
2290 cmp
->descent
= font_descent
;
2293 it
->pixel_width
= cmp
->pixel_width
;
2294 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2295 it
->descent
= it
->phys_descent
= cmp
->descent
;
2297 if (face
->box
!= FACE_NO_BOX
)
2299 int thick
= face
->box_line_width
;
2303 it
->ascent
+= thick
;
2304 it
->descent
+= thick
;
2309 if (it
->start_of_box_run_p
)
2310 it
->pixel_width
+= thick
;
2311 if (it
->end_of_box_run_p
)
2312 it
->pixel_width
+= thick
;
2315 /* If face has an overline, add the height of the overline
2316 (1 pixel) and a 1 pixel margin to the character height. */
2317 if (face
->overline_p
)
2320 take_vertical_position_into_account (it
);
2323 x_append_composite_glyph (it
);
2325 else if (it
->what
== IT_IMAGE
)
2326 x_produce_image_glyph (it
);
2327 else if (it
->what
== IT_STRETCH
)
2328 x_produce_stretch_glyph (it
);
2330 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2331 because this isn't true for images with `:ascent 100'. */
2332 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2333 if (it
->area
== TEXT_AREA
)
2334 it
->current_x
+= it
->pixel_width
;
2336 it
->descent
+= it
->extra_line_spacing
;
2338 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2339 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2340 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2341 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2345 /* Estimate the pixel height of the mode or top line on frame F.
2346 FACE_ID specifies what line's height to estimate. */
2349 x_estimate_mode_line_height (f
, face_id
)
2351 enum face_id face_id
;
2353 int height
= FONT_HEIGHT (FRAME_FONT (f
));
2355 /* This function is called so early when Emacs starts that the face
2356 cache and mode line face are not yet initialized. */
2357 if (FRAME_FACE_CACHE (f
))
2359 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2363 height
= FONT_HEIGHT (face
->font
);
2364 if (face
->box_line_width
> 0)
2365 height
+= 2 * face
->box_line_width
;
2373 /***********************************************************************
2375 ***********************************************************************/
2377 /* A sequence of glyphs to be drawn in the same face.
2379 This data structure is not really completely X specific, so it
2380 could possibly, at least partially, be useful for other systems. It
2381 is currently not part of the external redisplay interface because
2382 it's not clear what other systems will need. */
2386 /* X-origin of the string. */
2389 /* Y-origin and y-position of the base line of this string. */
2392 /* The width of the string, not including a face extension. */
2395 /* The width of the string, including a face extension. */
2396 int background_width
;
2398 /* The height of this string. This is the height of the line this
2399 string is drawn in, and can be different from the height of the
2400 font the string is drawn in. */
2403 /* Number of pixels this string overwrites in front of its x-origin.
2404 This number is zero if the string has an lbearing >= 0; it is
2405 -lbearing, if the string has an lbearing < 0. */
2408 /* Number of pixels this string overwrites past its right-most
2409 nominal x-position, i.e. x + width. Zero if the string's
2410 rbearing is <= its nominal width, rbearing - width otherwise. */
2413 /* The frame on which the glyph string is drawn. */
2416 /* The window on which the glyph string is drawn. */
2419 /* X display and window for convenience. */
2423 /* The glyph row for which this string was built. It determines the
2424 y-origin and height of the string. */
2425 struct glyph_row
*row
;
2427 /* The area within row. */
2428 enum glyph_row_area area
;
2430 /* Characters to be drawn, and number of characters. */
2434 /* A face-override for drawing cursors, mouse face and similar. */
2435 enum draw_glyphs_face hl
;
2437 /* Face in which this string is to be drawn. */
2440 /* Font in which this string is to be drawn. */
2443 /* Font info for this string. */
2444 struct font_info
*font_info
;
2446 /* Non-null means this string describes (part of) a composition.
2447 All characters from char2b are drawn composed. */
2448 struct composition
*cmp
;
2450 /* Index of this glyph string's first character in the glyph
2451 definition of CMP. If this is zero, this glyph string describes
2452 the first character of a composition. */
2455 /* 1 means this glyph strings face has to be drawn to the right end
2456 of the window's drawing area. */
2457 unsigned extends_to_end_of_line_p
: 1;
2459 /* 1 means the background of this string has been drawn. */
2460 unsigned background_filled_p
: 1;
2462 /* 1 means glyph string must be drawn with 16-bit functions. */
2463 unsigned two_byte_p
: 1;
2465 /* 1 means that the original font determined for drawing this glyph
2466 string could not be loaded. The member `font' has been set to
2467 the frame's default font in this case. */
2468 unsigned font_not_found_p
: 1;
2470 /* 1 means that the face in which this glyph string is drawn has a
2472 unsigned stippled_p
: 1;
2474 /* 1 means only the foreground of this glyph string must be drawn,
2475 and we should use the physical height of the line this glyph
2476 string appears in as clip rect. */
2477 unsigned for_overlaps_p
: 1;
2479 /* The GC to use for drawing this glyph string. */
2482 /* A pointer to the first glyph in the string. This glyph
2483 corresponds to char2b[0]. Needed to draw rectangles if
2484 font_not_found_p is 1. */
2485 struct glyph
*first_glyph
;
2487 /* Image, if any. */
2490 struct glyph_string
*next
, *prev
;
2497 x_dump_glyph_string (s
)
2498 struct glyph_string
*s
;
2500 fprintf (stderr
, "glyph string\n");
2501 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2502 s
->x
, s
->y
, s
->width
, s
->height
);
2503 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2504 fprintf (stderr
, " hl = %d\n", s
->hl
);
2505 fprintf (stderr
, " left overhang = %d, right = %d\n",
2506 s
->left_overhang
, s
->right_overhang
);
2507 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2508 fprintf (stderr
, " extends to end of line = %d\n",
2509 s
->extends_to_end_of_line_p
);
2510 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2511 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2514 #endif /* GLYPH_DEBUG */
2518 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2519 struct glyph_string
**,
2520 struct glyph_string
*,
2521 struct glyph_string
*));
2522 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2523 struct glyph_string
**,
2524 struct glyph_string
*,
2525 struct glyph_string
*));
2526 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2527 struct glyph_string
**,
2528 struct glyph_string
*));
2529 static int x_left_overwritten
P_ ((struct glyph_string
*));
2530 static int x_left_overwriting
P_ ((struct glyph_string
*));
2531 static int x_right_overwritten
P_ ((struct glyph_string
*));
2532 static int x_right_overwriting
P_ ((struct glyph_string
*));
2533 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2535 static void x_init_glyph_string
P_ ((struct glyph_string
*,
2536 XChar2b
*, struct window
*,
2538 enum glyph_row_area
, int,
2539 enum draw_glyphs_face
));
2540 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2541 enum glyph_row_area
, int, int,
2542 enum draw_glyphs_face
, int *, int *, int));
2543 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2544 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2545 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2547 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2548 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2549 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2550 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2551 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2552 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2553 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2554 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2555 static void x_get_glyph_overhangs
P_ ((struct glyph
*, struct frame
*,
2557 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2558 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
2559 unsigned long *, double, int));
2560 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2561 double, int, unsigned long));
2562 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2563 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2564 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2565 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2566 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
2567 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2568 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2570 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2571 int, int, int, int, XRectangle
*));
2572 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2573 int, int, int, XRectangle
*));
2574 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2575 enum glyph_row_area
));
2576 static int x_fill_stretch_glyph_string
P_ ((struct glyph_string
*,
2578 enum glyph_row_area
, int, int));
2581 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2585 /* Append the list of glyph strings with head H and tail T to the list
2586 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2589 x_append_glyph_string_lists (head
, tail
, h
, t
)
2590 struct glyph_string
**head
, **tail
;
2591 struct glyph_string
*h
, *t
;
2605 /* Prepend the list of glyph strings with head H and tail T to the
2606 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2610 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2611 struct glyph_string
**head
, **tail
;
2612 struct glyph_string
*h
, *t
;
2626 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2627 Set *HEAD and *TAIL to the resulting list. */
2630 x_append_glyph_string (head
, tail
, s
)
2631 struct glyph_string
**head
, **tail
;
2632 struct glyph_string
*s
;
2634 s
->next
= s
->prev
= NULL
;
2635 x_append_glyph_string_lists (head
, tail
, s
, s
);
2639 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2644 struct glyph_string
*s
;
2646 if (s
->font
== FRAME_FONT (s
->f
)
2647 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2648 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2650 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
2653 /* Cursor on non-default face: must merge. */
2657 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
2658 xgcv
.foreground
= s
->face
->background
;
2660 /* If the glyph would be invisible, try a different foreground. */
2661 if (xgcv
.foreground
== xgcv
.background
)
2662 xgcv
.foreground
= s
->face
->foreground
;
2663 if (xgcv
.foreground
== xgcv
.background
)
2664 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
2665 if (xgcv
.foreground
== xgcv
.background
)
2666 xgcv
.foreground
= s
->face
->foreground
;
2668 /* Make sure the cursor is distinct from text in this face. */
2669 if (xgcv
.background
== s
->face
->background
2670 && xgcv
.foreground
== s
->face
->foreground
)
2672 xgcv
.background
= s
->face
->foreground
;
2673 xgcv
.foreground
= s
->face
->background
;
2676 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2677 xgcv
.font
= s
->font
->fid
;
2678 xgcv
.graphics_exposures
= False
;
2679 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2681 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2682 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2685 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2686 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2688 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2693 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2696 x_set_mouse_face_gc (s
)
2697 struct glyph_string
*s
;
2702 /* What face has to be used last for the mouse face? */
2703 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2704 face
= FACE_FROM_ID (s
->f
, face_id
);
2706 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
2708 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2709 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2711 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2712 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2713 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2715 /* If font in this face is same as S->font, use it. */
2716 if (s
->font
== s
->face
->font
)
2717 s
->gc
= s
->face
->gc
;
2720 /* Otherwise construct scratch_cursor_gc with values from FACE
2725 xgcv
.background
= s
->face
->background
;
2726 xgcv
.foreground
= s
->face
->foreground
;
2727 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2728 xgcv
.font
= s
->font
->fid
;
2729 xgcv
.graphics_exposures
= False
;
2730 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2732 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2733 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2736 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2737 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2739 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2742 xassert (s
->gc
!= 0);
2746 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2747 Faces to use in the mode line have already been computed when the
2748 matrix was built, so there isn't much to do, here. */
2751 x_set_mode_line_face_gc (s
)
2752 struct glyph_string
*s
;
2754 s
->gc
= s
->face
->gc
;
2758 /* Set S->gc of glyph string S for drawing that glyph string. Set
2759 S->stippled_p to a non-zero value if the face of S has a stipple
2763 x_set_glyph_string_gc (s
)
2764 struct glyph_string
*s
;
2766 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2768 if (s
->hl
== DRAW_NORMAL_TEXT
)
2770 s
->gc
= s
->face
->gc
;
2771 s
->stippled_p
= s
->face
->stipple
!= 0;
2773 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2775 x_set_mode_line_face_gc (s
);
2776 s
->stippled_p
= s
->face
->stipple
!= 0;
2778 else if (s
->hl
== DRAW_CURSOR
)
2780 x_set_cursor_gc (s
);
2783 else if (s
->hl
== DRAW_MOUSE_FACE
)
2785 x_set_mouse_face_gc (s
);
2786 s
->stippled_p
= s
->face
->stipple
!= 0;
2788 else if (s
->hl
== DRAW_IMAGE_RAISED
2789 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2791 s
->gc
= s
->face
->gc
;
2792 s
->stippled_p
= s
->face
->stipple
!= 0;
2796 s
->gc
= s
->face
->gc
;
2797 s
->stippled_p
= s
->face
->stipple
!= 0;
2800 /* GC must have been set. */
2801 xassert (s
->gc
!= 0);
2805 /* Return in *R the clipping rectangle for glyph string S. */
2808 x_get_glyph_string_clip_rect (s
, r
)
2809 struct glyph_string
*s
;
2812 if (s
->row
->full_width_p
)
2814 /* Draw full-width. X coordinates are relative to S->w->left. */
2815 int canon_x
= CANON_X_UNIT (s
->f
);
2817 r
->x
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
2818 r
->width
= XFASTINT (s
->w
->width
) * canon_x
;
2820 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
2822 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
2823 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
2827 r
->x
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
2829 /* Unless displaying a mode or menu bar line, which are always
2830 fully visible, clip to the visible part of the row. */
2831 if (s
->w
->pseudo_window_p
)
2832 r
->height
= s
->row
->visible_height
;
2834 r
->height
= s
->height
;
2838 /* This is a text line that may be partially visible. */
2839 r
->x
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
2840 r
->width
= window_box_width (s
->w
, s
->area
);
2841 r
->height
= s
->row
->visible_height
;
2844 /* If S draws overlapping rows, it's sufficient to use the top and
2845 bottom of the window for clipping because this glyph string
2846 intentionally draws over other lines. */
2847 if (s
->for_overlaps_p
)
2849 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2850 r
->height
= window_text_bottom_y (s
->w
) - r
->y
;
2854 /* Don't use S->y for clipping because it doesn't take partially
2855 visible lines into account. For example, it can be negative for
2856 partially visible lines at the top of a window. */
2857 if (!s
->row
->full_width_p
2858 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2859 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2861 r
->y
= max (0, s
->row
->y
);
2863 /* If drawing a tool-bar window, draw it over the internal border
2864 at the top of the window. */
2865 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
2866 r
->y
-= s
->f
->output_data
.x
->internal_border_width
;
2869 r
->y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->y
);
2873 /* Set clipping for output of glyph string S. S may be part of a mode
2874 line or menu if we don't have X toolkit support. */
2877 x_set_glyph_string_clipping (s
)
2878 struct glyph_string
*s
;
2881 x_get_glyph_string_clip_rect (s
, &r
);
2882 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
2886 /* Compute left and right overhang of glyph string S. If S is a glyph
2887 string for a composition, assume overhangs don't exist. */
2890 x_compute_glyph_string_overhangs (s
)
2891 struct glyph_string
*s
;
2894 && s
->first_glyph
->type
== CHAR_GLYPH
)
2897 int direction
, font_ascent
, font_descent
;
2898 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
2899 &font_ascent
, &font_descent
, &cs
);
2900 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2901 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2906 /* Compute overhangs and x-positions for glyph string S and its
2907 predecessors, or successors. X is the starting x-position for S.
2908 BACKWARD_P non-zero means process predecessors. */
2911 x_compute_overhangs_and_x (s
, x
, backward_p
)
2912 struct glyph_string
*s
;
2920 x_compute_glyph_string_overhangs (s
);
2930 x_compute_glyph_string_overhangs (s
);
2939 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2940 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2941 assumed to be zero. */
2944 x_get_glyph_overhangs (glyph
, f
, left
, right
)
2945 struct glyph
*glyph
;
2951 if (glyph
->type
== CHAR_GLYPH
)
2955 struct font_info
*font_info
;
2959 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
2961 font_info
= FONT_INFO_FROM_ID (f
, face
->font_info_id
);
2963 && (pcm
= x_per_char_metric (font
, &char2b
)))
2965 if (pcm
->rbearing
> pcm
->width
)
2966 *right
= pcm
->rbearing
- pcm
->width
;
2967 if (pcm
->lbearing
< 0)
2968 *left
= -pcm
->lbearing
;
2974 /* Return the index of the first glyph preceding glyph string S that
2975 is overwritten by S because of S's left overhang. Value is -1
2976 if no glyphs are overwritten. */
2979 x_left_overwritten (s
)
2980 struct glyph_string
*s
;
2984 if (s
->left_overhang
)
2987 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2988 int first
= s
->first_glyph
- glyphs
;
2990 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
2991 x
-= glyphs
[i
].pixel_width
;
3002 /* Return the index of the first glyph preceding glyph string S that
3003 is overwriting S because of its right overhang. Value is -1 if no
3004 glyph in front of S overwrites S. */
3007 x_left_overwriting (s
)
3008 struct glyph_string
*s
;
3011 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3012 int first
= s
->first_glyph
- glyphs
;
3016 for (i
= first
- 1; i
>= 0; --i
)
3019 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3022 x
-= glyphs
[i
].pixel_width
;
3029 /* Return the index of the last glyph following glyph string S that is
3030 not overwritten by S because of S's right overhang. Value is -1 if
3031 no such glyph is found. */
3034 x_right_overwritten (s
)
3035 struct glyph_string
*s
;
3039 if (s
->right_overhang
)
3042 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3043 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3044 int end
= s
->row
->used
[s
->area
];
3046 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3047 x
+= glyphs
[i
].pixel_width
;
3056 /* Return the index of the last glyph following glyph string S that
3057 overwrites S because of its left overhang. Value is negative
3058 if no such glyph is found. */
3061 x_right_overwriting (s
)
3062 struct glyph_string
*s
;
3065 int end
= s
->row
->used
[s
->area
];
3066 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3067 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3071 for (i
= first
; i
< end
; ++i
)
3074 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3077 x
+= glyphs
[i
].pixel_width
;
3084 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3087 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3088 struct glyph_string
*s
;
3092 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
3093 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3094 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3095 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3099 /* Draw the background of glyph_string S. If S->background_filled_p
3100 is non-zero don't draw it. FORCE_P non-zero means draw the
3101 background even if it wouldn't be drawn normally. This is used
3102 when a string preceding S draws into the background of S, or S
3103 contains the first component of a composition. */
3106 x_draw_glyph_string_background (s
, force_p
)
3107 struct glyph_string
*s
;
3110 /* Nothing to do if background has already been drawn or if it
3111 shouldn't be drawn in the first place. */
3112 if (!s
->background_filled_p
)
3114 int box_line_width
= max (s
->face
->box_line_width
, 0);
3118 /* Fill background with a stipple pattern. */
3119 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3120 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3121 s
->y
+ box_line_width
,
3122 s
->background_width
,
3123 s
->height
- 2 * box_line_width
);
3124 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3125 s
->background_filled_p
= 1;
3127 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
3128 || s
->font_not_found_p
3129 || s
->extends_to_end_of_line_p
3132 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
3133 s
->background_width
,
3134 s
->height
- 2 * box_line_width
);
3135 s
->background_filled_p
= 1;
3141 /* Draw the foreground of glyph string S. */
3144 x_draw_glyph_string_foreground (s
)
3145 struct glyph_string
*s
;
3149 /* If first glyph of S has a left box line, start drawing the text
3150 of S to the right of that box line. */
3151 if (s
->face
->box
!= FACE_NO_BOX
3152 && s
->first_glyph
->left_box_line_p
)
3153 x
= s
->x
+ abs (s
->face
->box_line_width
);
3157 /* Draw characters of S as rectangles if S's font could not be
3159 if (s
->font_not_found_p
)
3161 for (i
= 0; i
< s
->nchars
; ++i
)
3163 struct glyph
*g
= s
->first_glyph
+ i
;
3164 XDrawRectangle (s
->display
, s
->window
,
3165 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3167 x
+= g
->pixel_width
;
3172 char *char1b
= (char *) s
->char2b
;
3173 int boff
= s
->font_info
->baseline_offset
;
3175 if (s
->font_info
->vertical_centering
)
3176 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3178 /* If we can use 8-bit functions, condense S->char2b. */
3180 for (i
= 0; i
< s
->nchars
; ++i
)
3181 char1b
[i
] = s
->char2b
[i
].byte2
;
3183 /* Draw text with XDrawString if background has already been
3184 filled. Otherwise, use XDrawImageString. (Note that
3185 XDrawImageString is usually faster than XDrawString.) Always
3186 use XDrawImageString when drawing the cursor so that there is
3187 no chance that characters under a box cursor are invisible. */
3188 if (s
->for_overlaps_p
3189 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3191 /* Draw characters with 16-bit or 8-bit functions. */
3193 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
3194 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3196 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
3197 s
->ybase
- boff
, char1b
, s
->nchars
);
3202 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
3203 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3205 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
3206 s
->ybase
- boff
, char1b
, s
->nchars
);
3211 /* Draw the foreground of composite glyph string S. */
3214 x_draw_composite_glyph_string_foreground (s
)
3215 struct glyph_string
*s
;
3219 /* If first glyph of S has a left box line, start drawing the text
3220 of S to the right of that box line. */
3221 if (s
->face
->box
!= FACE_NO_BOX
3222 && s
->first_glyph
->left_box_line_p
)
3223 x
= s
->x
+ abs (s
->face
->box_line_width
);
3227 /* S is a glyph string for a composition. S->gidx is the index of
3228 the first character drawn for glyphs of this composition.
3229 S->gidx == 0 means we are drawing the very first character of
3230 this composition. */
3232 /* Draw a rectangle for the composition if the font for the very
3233 first character of the composition could not be loaded. */
3234 if (s
->font_not_found_p
)
3237 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
3238 s
->width
- 1, s
->height
- 1);
3242 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3243 XDrawString16 (s
->display
, s
->window
, s
->gc
,
3244 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3245 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3251 #ifdef USE_X_TOOLKIT
3253 static struct frame
*x_frame_of_widget
P_ ((Widget
));
3254 static Boolean cvt_string_to_pixel
P_ ((Display
*, XrmValue
*, Cardinal
*,
3255 XrmValue
*, XrmValue
*, XtPointer
*));
3256 static void cvt_pixel_dtor
P_ ((XtAppContext
, XrmValue
*, XtPointer
,
3257 XrmValue
*, Cardinal
*));
3260 /* Return the frame on which widget WIDGET is used.. Abort if frame
3261 cannot be determined. */
3263 static struct frame
*
3264 x_frame_of_widget (widget
)
3267 struct x_display_info
*dpyinfo
;
3271 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3273 /* Find the top-level shell of the widget. Note that this function
3274 can be called when the widget is not yet realized, so XtWindow
3275 (widget) == 0. That's the reason we can't simply use
3276 x_any_window_to_frame. */
3277 while (!XtIsTopLevelShell (widget
))
3278 widget
= XtParent (widget
);
3280 /* Look for a frame with that top-level widget. Allocate the color
3281 on that frame to get the right gamma correction value. */
3282 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3283 if (GC_FRAMEP (XCAR (tail
))
3284 && (f
= XFRAME (XCAR (tail
)),
3285 (f
->output_data
.nothing
!= 1
3286 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3287 && f
->output_data
.x
->widget
== widget
)
3294 /* Allocate the color COLOR->pixel on the screen and display of
3295 widget WIDGET in colormap CMAP. If an exact match cannot be
3296 allocated, try the nearest color available. Value is non-zero
3297 if successful. This is called from lwlib. */
3300 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3305 struct frame
*f
= x_frame_of_widget (widget
);
3306 return x_alloc_nearest_color (f
, cmap
, color
);
3310 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3311 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3312 If this produces the same color as PIXEL, try a color where all RGB
3313 values have DELTA added. Return the allocated color in *PIXEL.
3314 DISPLAY is the X display, CMAP is the colormap to operate on.
3315 Value is non-zero if successful. */
3318 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
3322 unsigned long *pixel
;
3326 struct frame
*f
= x_frame_of_widget (widget
);
3327 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
3331 /* Structure specifying which arguments should be passed by Xt to
3332 cvt_string_to_pixel. We want the widget's screen and colormap. */
3334 static XtConvertArgRec cvt_string_to_pixel_args
[] =
3336 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
3338 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
3343 /* The address of this variable is returned by
3344 cvt_string_to_pixel. */
3346 static Pixel cvt_string_to_pixel_value
;
3349 /* Convert a color name to a pixel color.
3351 DPY is the display we are working on.
3353 ARGS is an array of *NARGS XrmValue structures holding additional
3354 information about the widget for which the conversion takes place.
3355 The contents of this array are determined by the specification
3356 in cvt_string_to_pixel_args.
3358 FROM is a pointer to an XrmValue which points to the color name to
3359 convert. TO is an XrmValue in which to return the pixel color.
3361 CLOSURE_RET is a pointer to user-data, in which we record if
3362 we allocated the color or not.
3364 Value is True if successful, False otherwise. */
3367 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
3371 XrmValue
*from
, *to
;
3372 XtPointer
*closure_ret
;
3382 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
3383 "wrongParameters", "cvt_string_to_pixel",
3385 "Screen and colormap args required", NULL
, NULL
);
3389 screen
= *(Screen
**) args
[0].addr
;
3390 cmap
= *(Colormap
*) args
[1].addr
;
3391 color_name
= (String
) from
->addr
;
3393 if (strcmp (color_name
, XtDefaultBackground
) == 0)
3395 *closure_ret
= (XtPointer
) False
;
3396 pixel
= WhitePixelOfScreen (screen
);
3398 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
3400 *closure_ret
= (XtPointer
) False
;
3401 pixel
= BlackPixelOfScreen (screen
);
3403 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
3404 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
3406 pixel
= color
.pixel
;
3407 *closure_ret
= (XtPointer
) True
;
3412 Cardinal nparams
= 1;
3414 params
[0] = color_name
;
3415 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
3416 "badValue", "cvt_string_to_pixel",
3417 "XtToolkitError", "Invalid color `%s'",
3422 if (to
->addr
!= NULL
)
3424 if (to
->size
< sizeof (Pixel
))
3426 to
->size
= sizeof (Pixel
);
3430 *(Pixel
*) to
->addr
= pixel
;
3434 cvt_string_to_pixel_value
= pixel
;
3435 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
3438 to
->size
= sizeof (Pixel
);
3443 /* Free a pixel color which was previously allocated via
3444 cvt_string_to_pixel. This is registered as the destructor
3445 for this type of resource via XtSetTypeConverter.
3447 APP is the application context in which we work.
3449 TO is a pointer to an XrmValue holding the color to free.
3450 CLOSURE is the value we stored in CLOSURE_RET for this color
3451 in cvt_string_to_pixel.
3453 ARGS and NARGS are like for cvt_string_to_pixel. */
3456 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
3465 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
3467 "Screen and colormap arguments required",
3470 else if (closure
!= NULL
)
3472 /* We did allocate the pixel, so free it. */
3473 Screen
*screen
= *(Screen
**) args
[0].addr
;
3474 Colormap cmap
= *(Colormap
*) args
[1].addr
;
3475 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
3476 (Pixel
*) to
->addr
, 1);
3481 #endif /* USE_X_TOOLKIT */
3484 /* Value is an array of XColor structures for the contents of the
3485 color map of display DPY. Set *NCELLS to the size of the array.
3486 Note that this probably shouldn't be called for large color maps,
3487 say a 24-bit TrueColor map. */
3489 static const XColor
*
3490 x_color_cells (dpy
, ncells
)
3494 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
3496 if (dpyinfo
->color_cells
== NULL
)
3498 Screen
*screen
= dpyinfo
->screen
;
3501 dpyinfo
->ncolor_cells
3502 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
3503 dpyinfo
->color_cells
3504 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
3505 * sizeof *dpyinfo
->color_cells
);
3507 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
3508 dpyinfo
->color_cells
[i
].pixel
= i
;
3510 XQueryColors (dpy
, dpyinfo
->cmap
,
3511 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
3514 *ncells
= dpyinfo
->ncolor_cells
;
3515 return dpyinfo
->color_cells
;
3519 /* On frame F, translate pixel colors to RGB values for the NCOLORS
3520 colors in COLORS. Use cached information, if available. */
3523 x_query_colors (f
, colors
, ncolors
)
3528 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3530 if (dpyinfo
->color_cells
)
3533 for (i
= 0; i
< ncolors
; ++i
)
3535 unsigned long pixel
= colors
[i
].pixel
;
3536 xassert (pixel
< dpyinfo
->ncolor_cells
);
3537 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
3538 colors
[i
] = dpyinfo
->color_cells
[pixel
];
3542 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
3546 /* On frame F, translate pixel color to RGB values for the color in
3547 COLOR. Use cached information, if available. */
3550 x_query_color (f
, color
)
3554 x_query_colors (f
, color
, 1);
3558 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
3559 exact match can't be allocated, try the nearest color available.
3560 Value is non-zero if successful. Set *COLOR to the color
3564 x_alloc_nearest_color_1 (dpy
, cmap
, color
)
3571 rc
= XAllocColor (dpy
, cmap
, color
);
3574 /* If we got to this point, the colormap is full, so we're going
3575 to try to get the next closest color. The algorithm used is
3576 a least-squares matching, which is what X uses for closest
3577 color matching with StaticColor visuals. */
3579 unsigned long nearest_delta
= ~0;
3581 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
3583 for (nearest
= i
= 0; i
< ncells
; ++i
)
3585 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3586 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3587 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3588 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3590 if (delta
< nearest_delta
)
3593 nearest_delta
= delta
;
3597 color
->red
= cells
[nearest
].red
;
3598 color
->green
= cells
[nearest
].green
;
3599 color
->blue
= cells
[nearest
].blue
;
3600 rc
= XAllocColor (dpy
, cmap
, color
);
3604 /* If allocation succeeded, and the allocated pixel color is not
3605 equal to a cached pixel color recorded earlier, there was a
3606 change in the colormap, so clear the color cache. */
3607 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
3608 XColor
*cached_color
;
3610 if (dpyinfo
->color_cells
3611 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
3612 (cached_color
->red
!= color
->red
3613 || cached_color
->blue
!= color
->blue
3614 || cached_color
->green
!= color
->green
)))
3616 xfree (dpyinfo
->color_cells
);
3617 dpyinfo
->color_cells
= NULL
;
3618 dpyinfo
->ncolor_cells
= 0;
3622 #ifdef DEBUG_X_COLORS
3624 register_color (color
->pixel
);
3625 #endif /* DEBUG_X_COLORS */
3631 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
3632 exact match can't be allocated, try the nearest color available.
3633 Value is non-zero if successful. Set *COLOR to the color
3637 x_alloc_nearest_color (f
, cmap
, color
)
3642 gamma_correct (f
, color
);
3643 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
3647 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3648 It's necessary to do this instead of just using PIXEL directly to
3649 get color reference counts right. */
3652 x_copy_color (f
, pixel
)
3654 unsigned long pixel
;
3658 color
.pixel
= pixel
;
3660 x_query_color (f
, &color
);
3661 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3663 #ifdef DEBUG_X_COLORS
3664 register_color (pixel
);
3670 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3671 It's necessary to do this instead of just using PIXEL directly to
3672 get color reference counts right. */
3675 x_copy_dpy_color (dpy
, cmap
, pixel
)
3678 unsigned long pixel
;
3682 color
.pixel
= pixel
;
3684 XQueryColor (dpy
, cmap
, &color
);
3685 XAllocColor (dpy
, cmap
, &color
);
3687 #ifdef DEBUG_X_COLORS
3688 register_color (pixel
);
3694 /* Brightness beyond which a color won't have its highlight brightness
3697 Nominally, highlight colors for `3d' faces are calculated by
3698 brightening an object's color by a constant scale factor, but this
3699 doesn't yield good results for dark colors, so for colors who's
3700 brightness is less than this value (on a scale of 0-65535) have an
3701 use an additional additive factor.
3703 The value here is set so that the default menu-bar/mode-line color
3704 (grey75) will not have its highlights changed at all. */
3705 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
3708 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3709 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3710 If this produces the same color as PIXEL, try a color where all RGB
3711 values have DELTA added. Return the allocated color in *PIXEL.
3712 DISPLAY is the X display, CMAP is the colormap to operate on.
3713 Value is non-zero if successful. */
3716 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
3720 unsigned long *pixel
;
3728 /* Get RGB color values. */
3729 color
.pixel
= *pixel
;
3730 x_query_color (f
, &color
);
3732 /* Change RGB values by specified FACTOR. Avoid overflow! */
3733 xassert (factor
>= 0);
3734 new.red
= min (0xffff, factor
* color
.red
);
3735 new.green
= min (0xffff, factor
* color
.green
);
3736 new.blue
= min (0xffff, factor
* color
.blue
);
3738 /* Calculate brightness of COLOR. */
3739 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
3741 /* We only boost colors that are darker than
3742 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3743 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3744 /* Make an additive adjustment to NEW, because it's dark enough so
3745 that scaling by FACTOR alone isn't enough. */
3747 /* How far below the limit this color is (0 - 1, 1 being darker). */
3748 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3749 /* The additive adjustment. */
3750 int min_delta
= delta
* dimness
* factor
/ 2;
3754 new.red
= max (0, new.red
- min_delta
);
3755 new.green
= max (0, new.green
- min_delta
);
3756 new.blue
= max (0, new.blue
- min_delta
);
3760 new.red
= min (0xffff, min_delta
+ new.red
);
3761 new.green
= min (0xffff, min_delta
+ new.green
);
3762 new.blue
= min (0xffff, min_delta
+ new.blue
);
3766 /* Try to allocate the color. */
3767 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3770 if (new.pixel
== *pixel
)
3772 /* If we end up with the same color as before, try adding
3773 delta to the RGB values. */
3774 x_free_colors (f
, &new.pixel
, 1);
3776 new.red
= min (0xffff, delta
+ color
.red
);
3777 new.green
= min (0xffff, delta
+ color
.green
);
3778 new.blue
= min (0xffff, delta
+ color
.blue
);
3779 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3790 /* Set up the foreground color for drawing relief lines of glyph
3791 string S. RELIEF is a pointer to a struct relief containing the GC
3792 with which lines will be drawn. Use a color that is FACTOR or
3793 DELTA lighter or darker than the relief's background which is found
3794 in S->f->output_data.x->relief_background. If such a color cannot
3795 be allocated, use DEFAULT_PIXEL, instead. */
3798 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3800 struct relief
*relief
;
3803 unsigned long default_pixel
;
3806 struct x_output
*di
= f
->output_data
.x
;
3807 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
3808 unsigned long pixel
;
3809 unsigned long background
= di
->relief_background
;
3810 Colormap cmap
= FRAME_X_COLORMAP (f
);
3811 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3812 Display
*dpy
= FRAME_X_DISPLAY (f
);
3814 xgcv
.graphics_exposures
= False
;
3815 xgcv
.line_width
= 1;
3817 /* Free previously allocated color. The color cell will be reused
3818 when it has been freed as many times as it was allocated, so this
3819 doesn't affect faces using the same colors. */
3821 && relief
->allocated_p
)
3823 x_free_colors (f
, &relief
->pixel
, 1);
3824 relief
->allocated_p
= 0;
3827 /* Allocate new color. */
3828 xgcv
.foreground
= default_pixel
;
3830 if (dpyinfo
->n_planes
!= 1
3831 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
3833 relief
->allocated_p
= 1;
3834 xgcv
.foreground
= relief
->pixel
= pixel
;
3837 if (relief
->gc
== 0)
3839 xgcv
.stipple
= dpyinfo
->gray
;
3841 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
3844 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
3848 /* Set up colors for the relief lines around glyph string S. */
3851 x_setup_relief_colors (s
)
3852 struct glyph_string
*s
;
3854 struct x_output
*di
= s
->f
->output_data
.x
;
3855 unsigned long color
;
3857 if (s
->face
->use_box_color_for_shadows_p
)
3858 color
= s
->face
->box_color
;
3863 /* Get the background color of the face. */
3864 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3865 color
= xgcv
.background
;
3868 if (di
->white_relief
.gc
== 0
3869 || color
!= di
->relief_background
)
3871 di
->relief_background
= color
;
3872 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3873 WHITE_PIX_DEFAULT (s
->f
));
3874 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3875 BLACK_PIX_DEFAULT (s
->f
));
3880 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3881 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3882 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3883 relief. LEFT_P non-zero means draw a relief on the left side of
3884 the rectangle. RIGHT_P non-zero means draw a relief on the right
3885 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3889 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3890 raised_p
, left_p
, right_p
, clip_rect
)
3892 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3893 XRectangle
*clip_rect
;
3899 gc
= f
->output_data
.x
->white_relief
.gc
;
3901 gc
= f
->output_data
.x
->black_relief
.gc
;
3902 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3905 for (i
= 0; i
< width
; ++i
)
3906 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3907 left_x
+ i
* left_p
, top_y
+ i
,
3908 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3912 for (i
= 0; i
< width
; ++i
)
3913 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3914 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
3916 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3918 gc
= f
->output_data
.x
->black_relief
.gc
;
3920 gc
= f
->output_data
.x
->white_relief
.gc
;
3921 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3924 for (i
= 0; i
< width
; ++i
)
3925 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3926 left_x
+ i
* left_p
+ 1, bottom_y
- i
,
3927 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3931 for (i
= 0; i
< width
; ++i
)
3932 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3933 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3935 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3939 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3940 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3941 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3942 left side of the rectangle. RIGHT_P non-zero means draw a line
3943 on the right side of the rectangle. CLIP_RECT is the clipping
3944 rectangle to use when drawing. */
3947 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3948 left_p
, right_p
, clip_rect
)
3949 struct glyph_string
*s
;
3950 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
;
3951 XRectangle
*clip_rect
;
3955 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3956 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3957 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
3960 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3961 left_x
, top_y
, right_x
- left_x
+ 1, width
);
3965 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3966 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
3969 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3970 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
3974 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3975 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
3977 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3978 XSetClipMask (s
->display
, s
->gc
, None
);
3982 /* Draw a box around glyph string S. */
3985 x_draw_glyph_string_box (s
)
3986 struct glyph_string
*s
;
3988 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3989 int left_p
, right_p
;
3990 struct glyph
*last_glyph
;
3991 XRectangle clip_rect
;
3993 last_x
= window_box_right (s
->w
, s
->area
);
3994 if (s
->row
->full_width_p
3995 && !s
->w
->pseudo_window_p
)
3997 last_x
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s
->f
);
3998 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
3999 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
4002 /* The glyph that may have a right box line. */
4003 last_glyph
= (s
->cmp
|| s
->img
4005 : s
->first_glyph
+ s
->nchars
- 1);
4007 width
= abs (s
->face
->box_line_width
);
4008 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
4010 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
4012 : min (last_x
, s
->x
+ s
->background_width
) - 1);
4014 bottom_y
= top_y
+ s
->height
- 1;
4016 left_p
= (s
->first_glyph
->left_box_line_p
4017 || (s
->hl
== DRAW_MOUSE_FACE
4019 || s
->prev
->hl
!= s
->hl
)));
4020 right_p
= (last_glyph
->right_box_line_p
4021 || (s
->hl
== DRAW_MOUSE_FACE
4023 || s
->next
->hl
!= s
->hl
)));
4025 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4027 if (s
->face
->box
== FACE_SIMPLE_BOX
)
4028 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
4029 left_p
, right_p
, &clip_rect
);
4032 x_setup_relief_colors (s
);
4033 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
4034 width
, raised_p
, left_p
, right_p
, &clip_rect
);
4039 /* Draw foreground of image glyph string S. */
4042 x_draw_image_foreground (s
)
4043 struct glyph_string
*s
;
4046 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
4048 /* If first glyph of S has a left box line, start drawing it to the
4049 right of that line. */
4050 if (s
->face
->box
!= FACE_NO_BOX
4051 && s
->first_glyph
->left_box_line_p
)
4052 x
= s
->x
+ abs (s
->face
->box_line_width
);
4056 /* If there is a margin around the image, adjust x- and y-position
4058 x
+= s
->img
->hmargin
;
4059 y
+= s
->img
->vmargin
;
4065 /* We can't set both a clip mask and use XSetClipRectangles
4066 because the latter also sets a clip mask. We also can't
4067 trust on the shape extension to be available
4068 (XShapeCombineRegion). So, compute the rectangle to draw
4070 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4073 XRectangle clip_rect
, image_rect
, r
;
4075 xgcv
.clip_mask
= s
->img
->mask
;
4076 xgcv
.clip_x_origin
= x
;
4077 xgcv
.clip_y_origin
= y
;
4078 xgcv
.function
= GXcopy
;
4079 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4081 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4084 image_rect
.width
= s
->img
->width
;
4085 image_rect
.height
= s
->img
->height
;
4086 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
4087 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
4088 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
4092 unsigned long mask
= GCClipXOrigin
| GCClipYOrigin
| GCFunction
;
4094 XRectangle clip_rect
, image_rect
, r
;
4096 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4099 image_rect
.width
= s
->img
->width
;
4100 image_rect
.height
= s
->img
->height
;
4101 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
4102 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
4103 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
4105 /* When the image has a mask, we can expect that at
4106 least part of a mouse highlight or a block cursor will
4107 be visible. If the image doesn't have a mask, make
4108 a block cursor visible by drawing a rectangle around
4109 the image. I believe it's looking better if we do
4110 nothing here for mouse-face. */
4111 if (s
->hl
== DRAW_CURSOR
)
4112 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
4113 s
->img
->width
- 1, s
->img
->height
- 1);
4117 /* Draw a rectangle if image could not be loaded. */
4118 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
4119 s
->img
->width
- 1, s
->img
->height
- 1);
4123 /* Draw a relief around the image glyph string S. */
4126 x_draw_image_relief (s
)
4127 struct glyph_string
*s
;
4129 int x0
, y0
, x1
, y1
, thick
, raised_p
;
4132 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
4134 /* If first glyph of S has a left box line, start drawing it to the
4135 right of that line. */
4136 if (s
->face
->box
!= FACE_NO_BOX
4137 && s
->first_glyph
->left_box_line_p
)
4138 x
= s
->x
+ abs (s
->face
->box_line_width
);
4142 /* If there is a margin around the image, adjust x- and y-position
4144 x
+= s
->img
->hmargin
;
4145 y
+= s
->img
->vmargin
;
4147 if (s
->hl
== DRAW_IMAGE_SUNKEN
4148 || s
->hl
== DRAW_IMAGE_RAISED
)
4150 thick
= tool_bar_button_relief
> 0 ? tool_bar_button_relief
: 3;
4151 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
4155 thick
= abs (s
->img
->relief
);
4156 raised_p
= s
->img
->relief
> 0;
4161 x1
= x
+ s
->img
->width
+ thick
- 1;
4162 y1
= y
+ s
->img
->height
+ thick
- 1;
4164 x_setup_relief_colors (s
);
4165 x_get_glyph_string_clip_rect (s
, &r
);
4166 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
4170 /* Draw the foreground of image glyph string S to PIXMAP. */
4173 x_draw_image_foreground_1 (s
, pixmap
)
4174 struct glyph_string
*s
;
4178 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
4180 /* If first glyph of S has a left box line, start drawing it to the
4181 right of that line. */
4182 if (s
->face
->box
!= FACE_NO_BOX
4183 && s
->first_glyph
->left_box_line_p
)
4184 x
= abs (s
->face
->box_line_width
);
4188 /* If there is a margin around the image, adjust x- and y-position
4190 x
+= s
->img
->hmargin
;
4191 y
+= s
->img
->vmargin
;
4197 /* We can't set both a clip mask and use XSetClipRectangles
4198 because the latter also sets a clip mask. We also can't
4199 trust on the shape extension to be available
4200 (XShapeCombineRegion). So, compute the rectangle to draw
4202 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4206 xgcv
.clip_mask
= s
->img
->mask
;
4207 xgcv
.clip_x_origin
= x
;
4208 xgcv
.clip_y_origin
= y
;
4209 xgcv
.function
= GXcopy
;
4210 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4212 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4213 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4214 XSetClipMask (s
->display
, s
->gc
, None
);
4218 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4219 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4221 /* When the image has a mask, we can expect that at
4222 least part of a mouse highlight or a block cursor will
4223 be visible. If the image doesn't have a mask, make
4224 a block cursor visible by drawing a rectangle around
4225 the image. I believe it's looking better if we do
4226 nothing here for mouse-face. */
4227 if (s
->hl
== DRAW_CURSOR
)
4228 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
4229 s
->img
->width
- 1, s
->img
->height
- 1);
4233 /* Draw a rectangle if image could not be loaded. */
4234 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
4235 s
->img
->width
- 1, s
->img
->height
- 1);
4239 /* Draw part of the background of glyph string S. X, Y, W, and H
4240 give the rectangle to draw. */
4243 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4244 struct glyph_string
*s
;
4249 /* Fill background with a stipple pattern. */
4250 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4251 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4252 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4255 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4259 /* Draw image glyph string S.
4262 s->x +-------------------------
4265 | +-------------------------
4268 | | +-------------------
4274 x_draw_image_glyph_string (s
)
4275 struct glyph_string
*s
;
4278 int box_line_hwidth
= abs (s
->face
->box_line_width
);
4279 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
4281 Pixmap pixmap
= None
;
4283 height
= s
->height
- 2 * box_line_vwidth
;
4285 /* Fill background with face under the image. Do it only if row is
4286 taller than image or if image has a clip mask to reduce
4288 s
->stippled_p
= s
->face
->stipple
!= 0;
4289 if (height
> s
->img
->height
4293 || s
->img
->pixmap
== 0
4294 || s
->width
!= s
->background_width
)
4296 if (box_line_hwidth
&& s
->first_glyph
->left_box_line_p
)
4297 x
= s
->x
+ box_line_hwidth
;
4301 y
= s
->y
+ box_line_vwidth
;
4305 /* Create a pixmap as large as the glyph string. Fill it
4306 with the background color. Copy the image to it, using
4307 its mask. Copy the temporary pixmap to the display. */
4308 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4309 int depth
= DefaultDepthOfScreen (screen
);
4311 /* Create a pixmap as large as the glyph string. */
4312 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4313 s
->background_width
,
4316 /* Don't clip in the following because we're working on the
4318 XSetClipMask (s
->display
, s
->gc
, None
);
4320 /* Fill the pixmap with the background color/stipple. */
4323 /* Fill background with a stipple pattern. */
4324 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4325 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4326 0, 0, s
->background_width
, s
->height
);
4327 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4332 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4334 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4335 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4336 0, 0, s
->background_width
, s
->height
);
4337 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4341 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4343 s
->background_filled_p
= 1;
4346 /* Draw the foreground. */
4349 x_draw_image_foreground_1 (s
, pixmap
);
4350 x_set_glyph_string_clipping (s
);
4351 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
4352 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
4353 XFreePixmap (s
->display
, pixmap
);
4356 x_draw_image_foreground (s
);
4358 /* If we must draw a relief around the image, do it. */
4360 || s
->hl
== DRAW_IMAGE_RAISED
4361 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4362 x_draw_image_relief (s
);
4366 /* Draw stretch glyph string S. */
4369 x_draw_stretch_glyph_string (s
)
4370 struct glyph_string
*s
;
4372 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4373 s
->stippled_p
= s
->face
->stipple
!= 0;
4375 if (s
->hl
== DRAW_CURSOR
4376 && !x_stretch_cursor_p
)
4378 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4379 as wide as the stretch glyph. */
4380 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4383 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4385 /* Clear rest using the GC of the original non-cursor face. */
4386 if (width
< s
->background_width
)
4388 int x
= s
->x
+ width
, y
= s
->y
;
4389 int w
= s
->background_width
- width
, h
= s
->height
;
4393 if (s
->row
->mouse_face_p
4394 && cursor_in_mouse_face_p (s
->w
))
4396 x_set_mouse_face_gc (s
);
4402 x_get_glyph_string_clip_rect (s
, &r
);
4403 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
4405 if (s
->face
->stipple
)
4407 /* Fill background with a stipple pattern. */
4408 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4409 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4410 XSetFillStyle (s
->display
, gc
, FillSolid
);
4415 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
4416 XSetForeground (s
->display
, gc
, xgcv
.background
);
4417 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4418 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
4422 else if (!s
->background_filled_p
)
4423 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4426 s
->background_filled_p
= 1;
4430 /* Draw glyph string S. */
4433 x_draw_glyph_string (s
)
4434 struct glyph_string
*s
;
4436 int relief_drawn_p
= 0;
4438 /* If S draws into the background of its successor, draw the
4439 background of the successor first so that S can draw into it.
4440 This makes S->next use XDrawString instead of XDrawImageString. */
4441 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4443 xassert (s
->next
->img
== NULL
);
4444 x_set_glyph_string_gc (s
->next
);
4445 x_set_glyph_string_clipping (s
->next
);
4446 x_draw_glyph_string_background (s
->next
, 1);
4449 /* Set up S->gc, set clipping and draw S. */
4450 x_set_glyph_string_gc (s
);
4451 x_set_glyph_string_clipping (s
);
4453 /* Draw relief (if any) in advance for char/composition so that the
4454 glyph string can be drawn over it. */
4455 if (!s
->for_overlaps_p
4456 && s
->face
->box
!= FACE_NO_BOX
4457 && (s
->first_glyph
->type
== CHAR_GLYPH
4458 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
4461 x_draw_glyph_string_background (s
, 1);
4462 x_draw_glyph_string_box (s
);
4466 switch (s
->first_glyph
->type
)
4469 x_draw_image_glyph_string (s
);
4473 x_draw_stretch_glyph_string (s
);
4477 if (s
->for_overlaps_p
)
4478 s
->background_filled_p
= 1;
4480 x_draw_glyph_string_background (s
, 0);
4481 x_draw_glyph_string_foreground (s
);
4484 case COMPOSITE_GLYPH
:
4485 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4486 s
->background_filled_p
= 1;
4488 x_draw_glyph_string_background (s
, 1);
4489 x_draw_composite_glyph_string_foreground (s
);
4496 if (!s
->for_overlaps_p
)
4498 /* Draw underline. */
4499 if (s
->face
->underline_p
)
4501 unsigned long tem
, h
;
4504 /* Get the underline thickness. Default is 1 pixel. */
4505 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
4508 /* Get the underline position. This is the recommended
4509 vertical offset in pixels from the baseline to the top of
4510 the underline. This is a signed value according to the
4511 specs, and its default is
4513 ROUND ((maximum descent) / 2), with
4514 ROUND(x) = floor (x + 0.5) */
4516 if (x_use_underline_position_properties
4517 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
4518 y
= s
->ybase
+ (long) tem
;
4519 else if (s
->face
->font
)
4520 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
4522 y
= s
->y
+ s
->height
- h
;
4524 if (s
->face
->underline_defaulted_p
)
4525 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4526 s
->x
, y
, s
->width
, h
);
4530 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4531 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
4532 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4533 s
->x
, y
, s
->width
, h
);
4534 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4538 /* Draw overline. */
4539 if (s
->face
->overline_p
)
4541 unsigned long dy
= 0, h
= 1;
4543 if (s
->face
->overline_color_defaulted_p
)
4544 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4549 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4550 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4551 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4553 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4557 /* Draw strike-through. */
4558 if (s
->face
->strike_through_p
)
4560 unsigned long h
= 1;
4561 unsigned long dy
= (s
->height
- h
) / 2;
4563 if (s
->face
->strike_through_color_defaulted_p
)
4564 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4569 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4570 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4571 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4573 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4577 /* Draw relief if not yet drawn. */
4578 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
4579 x_draw_glyph_string_box (s
);
4582 /* Reset clipping. */
4583 XSetClipMask (s
->display
, s
->gc
, None
);
4587 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4588 struct face
**, int));
4591 /* Fill glyph string S with composition components specified by S->cmp.
4593 FACES is an array of faces for all components of this composition.
4594 S->gidx is the index of the first component for S.
4595 OVERLAPS_P non-zero means S should draw the foreground only, and
4596 use its physical height for clipping.
4598 Value is the index of a component not in S. */
4601 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4602 struct glyph_string
*s
;
4603 struct face
**faces
;
4610 s
->for_overlaps_p
= overlaps_p
;
4612 s
->face
= faces
[s
->gidx
];
4613 s
->font
= s
->face
->font
;
4614 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4616 /* For all glyphs of this composition, starting at the offset
4617 S->gidx, until we reach the end of the definition or encounter a
4618 glyph that requires the different face, add it to S. */
4620 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4623 /* All glyph strings for the same composition has the same width,
4624 i.e. the width set for the first component of the composition. */
4626 s
->width
= s
->first_glyph
->pixel_width
;
4628 /* If the specified font could not be loaded, use the frame's
4629 default font, but record the fact that we couldn't load it in
4630 the glyph string so that we can draw rectangles for the
4631 characters of the glyph string. */
4632 if (s
->font
== NULL
)
4634 s
->font_not_found_p
= 1;
4635 s
->font
= FRAME_FONT (s
->f
);
4638 /* Adjust base line for subscript/superscript text. */
4639 s
->ybase
+= s
->first_glyph
->voffset
;
4641 xassert (s
->face
&& s
->face
->gc
);
4643 /* This glyph string must always be drawn with 16-bit functions. */
4646 return s
->gidx
+ s
->nchars
;
4650 /* Fill glyph string S from a sequence of character glyphs.
4652 FACE_ID is the face id of the string. START is the index of the
4653 first glyph to consider, END is the index of the last + 1.
4654 OVERLAPS_P non-zero means S should draw the foreground only, and
4655 use its physical height for clipping.
4657 Value is the index of the first glyph not in S. */
4660 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4661 struct glyph_string
*s
;
4663 int start
, end
, overlaps_p
;
4665 struct glyph
*glyph
, *last
;
4667 int glyph_not_available_p
;
4669 xassert (s
->f
== XFRAME (s
->w
->frame
));
4670 xassert (s
->nchars
== 0);
4671 xassert (start
>= 0 && end
> start
);
4673 s
->for_overlaps_p
= overlaps_p
,
4674 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4675 last
= s
->row
->glyphs
[s
->area
] + end
;
4676 voffset
= glyph
->voffset
;
4678 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4681 && glyph
->type
== CHAR_GLYPH
4682 && glyph
->voffset
== voffset
4683 /* Same face id implies same font, nowadays. */
4684 && glyph
->face_id
== face_id
4685 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4689 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4690 s
->char2b
+ s
->nchars
,
4692 s
->two_byte_p
= two_byte_p
;
4694 xassert (s
->nchars
<= end
- start
);
4695 s
->width
+= glyph
->pixel_width
;
4699 s
->font
= s
->face
->font
;
4700 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4702 /* If the specified font could not be loaded, use the frame's font,
4703 but record the fact that we couldn't load it in
4704 S->font_not_found_p so that we can draw rectangles for the
4705 characters of the glyph string. */
4706 if (s
->font
== NULL
|| glyph_not_available_p
)
4708 s
->font_not_found_p
= 1;
4709 s
->font
= FRAME_FONT (s
->f
);
4712 /* Adjust base line for subscript/superscript text. */
4713 s
->ybase
+= voffset
;
4715 xassert (s
->face
&& s
->face
->gc
);
4716 return glyph
- s
->row
->glyphs
[s
->area
];
4720 /* Fill glyph string S from image glyph S->first_glyph. */
4723 x_fill_image_glyph_string (s
)
4724 struct glyph_string
*s
;
4726 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4727 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4729 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4730 s
->font
= s
->face
->font
;
4731 s
->width
= s
->first_glyph
->pixel_width
;
4733 /* Adjust base line for subscript/superscript text. */
4734 s
->ybase
+= s
->first_glyph
->voffset
;
4738 /* Fill glyph string S from a sequence of stretch glyphs.
4740 ROW is the glyph row in which the glyphs are found, AREA is the
4741 area within the row. START is the index of the first glyph to
4742 consider, END is the index of the last + 1.
4744 Value is the index of the first glyph not in S. */
4747 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4748 struct glyph_string
*s
;
4749 struct glyph_row
*row
;
4750 enum glyph_row_area area
;
4753 struct glyph
*glyph
, *last
;
4754 int voffset
, face_id
;
4756 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4758 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4759 last
= s
->row
->glyphs
[s
->area
] + end
;
4760 face_id
= glyph
->face_id
;
4761 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4762 s
->font
= s
->face
->font
;
4763 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4764 s
->width
= glyph
->pixel_width
;
4765 voffset
= glyph
->voffset
;
4769 && glyph
->type
== STRETCH_GLYPH
4770 && glyph
->voffset
== voffset
4771 && glyph
->face_id
== face_id
);
4773 s
->width
+= glyph
->pixel_width
;
4775 /* Adjust base line for subscript/superscript text. */
4776 s
->ybase
+= voffset
;
4778 /* The case that face->gc == 0 is handled when drawing the glyph
4779 string by calling PREPARE_FACE_FOR_DISPLAY. */
4781 return glyph
- s
->row
->glyphs
[s
->area
];
4785 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4786 of XChar2b structures for S; it can't be allocated in
4787 x_init_glyph_string because it must be allocated via `alloca'. W
4788 is the window on which S is drawn. ROW and AREA are the glyph row
4789 and area within the row from which S is constructed. START is the
4790 index of the first glyph structure covered by S. HL is a
4791 face-override for drawing S. */
4794 x_init_glyph_string (s
, char2b
, w
, row
, area
, start
, hl
)
4795 struct glyph_string
*s
;
4798 struct glyph_row
*row
;
4799 enum glyph_row_area area
;
4801 enum draw_glyphs_face hl
;
4803 bzero (s
, sizeof *s
);
4805 s
->f
= XFRAME (w
->frame
);
4806 s
->display
= FRAME_X_DISPLAY (s
->f
);
4807 s
->window
= FRAME_X_WINDOW (s
->f
);
4812 s
->first_glyph
= row
->glyphs
[area
] + start
;
4813 s
->height
= row
->height
;
4814 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4816 /* Display the internal border below the tool-bar window. */
4817 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4818 s
->y
-= s
->f
->output_data
.x
->internal_border_width
;
4820 s
->ybase
= s
->y
+ row
->ascent
;
4824 /* Set background width of glyph string S. START is the index of the
4825 first glyph following S. LAST_X is the right-most x-position + 1
4826 in the drawing area. */
4829 x_set_glyph_string_background_width (s
, start
, last_x
)
4830 struct glyph_string
*s
;
4834 /* If the face of this glyph string has to be drawn to the end of
4835 the drawing area, set S->extends_to_end_of_line_p. */
4836 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4838 if (start
== s
->row
->used
[s
->area
]
4839 && s
->area
== TEXT_AREA
4840 && ((s
->hl
== DRAW_NORMAL_TEXT
4841 && (s
->row
->fill_line_p
4842 || s
->face
->background
!= default_face
->background
4843 || s
->face
->stipple
!= default_face
->stipple
4844 || s
->row
->mouse_face_p
))
4845 || s
->hl
== DRAW_MOUSE_FACE
))
4846 s
->extends_to_end_of_line_p
= 1;
4848 /* If S extends its face to the end of the line, set its
4849 background_width to the distance to the right edge of the drawing
4851 if (s
->extends_to_end_of_line_p
)
4852 s
->background_width
= last_x
- s
->x
+ 1;
4854 s
->background_width
= s
->width
;
4858 /* Add a glyph string for a stretch glyph to the list of strings
4859 between HEAD and TAIL. START is the index of the stretch glyph in
4860 row area AREA of glyph row ROW. END is the index of the last glyph
4861 in that glyph row area. X is the current output position assigned
4862 to the new glyph string constructed. HL overrides that face of the
4863 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4864 is the right-most x-position of the drawing area. */
4866 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4867 and below -- keep them on one line. */
4868 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4871 s = (struct glyph_string *) alloca (sizeof *s); \
4872 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4873 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4874 x_append_glyph_string (&HEAD, &TAIL, s); \
4880 /* Add a glyph string for an image glyph to the list of strings
4881 between HEAD and TAIL. START is the index of the image glyph in
4882 row area AREA of glyph row ROW. END is the index of the last glyph
4883 in that glyph row area. X is the current output position assigned
4884 to the new glyph string constructed. HL overrides that face of the
4885 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4886 is the right-most x-position of the drawing area. */
4888 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4891 s = (struct glyph_string *) alloca (sizeof *s); \
4892 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4893 x_fill_image_glyph_string (s); \
4894 x_append_glyph_string (&HEAD, &TAIL, s); \
4901 /* Add a glyph string for a sequence of character glyphs to the list
4902 of strings between HEAD and TAIL. START is the index of the first
4903 glyph in row area AREA of glyph row ROW that is part of the new
4904 glyph string. END is the index of the last glyph in that glyph row
4905 area. X is the current output position assigned to the new glyph
4906 string constructed. HL overrides that face of the glyph; e.g. it
4907 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4908 right-most x-position of the drawing area. */
4910 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4916 c = (ROW)->glyphs[AREA][START].u.ch; \
4917 face_id = (ROW)->glyphs[AREA][START].face_id; \
4919 s = (struct glyph_string *) alloca (sizeof *s); \
4920 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4921 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4922 x_append_glyph_string (&HEAD, &TAIL, s); \
4924 START = x_fill_glyph_string (s, face_id, START, END, \
4930 /* Add a glyph string for a composite sequence to the list of strings
4931 between HEAD and TAIL. START is the index of the first glyph in
4932 row area AREA of glyph row ROW that is part of the new glyph
4933 string. END is the index of the last glyph in that glyph row area.
4934 X is the current output position assigned to the new glyph string
4935 constructed. HL overrides that face of the glyph; e.g. it is
4936 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4937 x-position of the drawing area. */
4939 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4941 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4942 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4943 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4944 struct composition *cmp = composition_table[cmp_id]; \
4945 int glyph_len = cmp->glyph_len; \
4947 struct face **faces; \
4948 struct glyph_string *first_s = NULL; \
4951 base_face = base_face->ascii_face; \
4952 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4953 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4954 /* At first, fill in `char2b' and `faces'. */ \
4955 for (n = 0; n < glyph_len; n++) \
4957 int c = COMPOSITION_GLYPH (cmp, n); \
4958 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4959 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4960 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4961 this_face_id, char2b + n, 1); \
4964 /* Make glyph_strings for each glyph sequence that is drawable by \
4965 the same face, and append them to HEAD/TAIL. */ \
4966 for (n = 0; n < cmp->glyph_len;) \
4968 s = (struct glyph_string *) alloca (sizeof *s); \
4969 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
4970 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4978 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4986 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4987 of AREA of glyph row ROW on window W between indices START and END.
4988 HL overrides the face for drawing glyph strings, e.g. it is
4989 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4990 x-positions of the drawing area.
4992 This is an ugly monster macro construct because we must use alloca
4993 to allocate glyph strings (because x_draw_glyphs can be called
4996 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4999 HEAD = TAIL = NULL; \
5000 while (START < END) \
5002 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
5003 switch (first_glyph->type) \
5006 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
5007 TAIL, HL, X, LAST_X, \
5011 case COMPOSITE_GLYPH: \
5012 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
5013 HEAD, TAIL, HL, X, LAST_X,\
5017 case STRETCH_GLYPH: \
5018 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
5019 HEAD, TAIL, HL, X, LAST_X); \
5023 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
5024 TAIL, HL, X, LAST_X); \
5031 x_set_glyph_string_background_width (s, START, LAST_X); \
5038 /* Draw glyphs between START and END in AREA of ROW on window W,
5039 starting at x-position X. X is relative to AREA in W. HL is a
5040 face-override with the following meaning:
5042 DRAW_NORMAL_TEXT draw normally
5043 DRAW_CURSOR draw in cursor face
5044 DRAW_MOUSE_FACE draw in mouse face.
5045 DRAW_INVERSE_VIDEO draw in mode line face
5046 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
5047 DRAW_IMAGE_RAISED draw an image with a raised relief around it
5049 If REAL_START is non-null, return in *REAL_START the real starting
5050 position for display. This can be different from START in case
5051 overlapping glyphs must be displayed. If REAL_END is non-null,
5052 return in *REAL_END the real end position for display. This can be
5053 different from END in case overlapping glyphs must be displayed.
5055 If OVERLAPS_P is non-zero, draw only the foreground of characters
5056 and clip to the physical height of ROW.
5058 Value is the x-position reached, relative to AREA of W. */
5061 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, real_start
, real_end
,
5065 struct glyph_row
*row
;
5066 enum glyph_row_area area
;
5068 enum draw_glyphs_face hl
;
5069 int *real_start
, *real_end
;
5072 struct glyph_string
*head
, *tail
;
5073 struct glyph_string
*s
;
5074 int last_x
, area_width
;
5078 /* Let's rather be paranoid than getting a SEGV. */
5079 end
= min (end
, row
->used
[area
]);
5080 start
= max (0, start
);
5081 start
= min (end
, start
);
5083 *real_start
= start
;
5087 /* Translate X to frame coordinates. Set last_x to the right
5088 end of the drawing area. */
5089 if (row
->full_width_p
)
5091 /* X is relative to the left edge of W, without scroll bars
5093 struct frame
*f
= XFRAME (w
->frame
);
5094 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
5095 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
5098 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5099 last_x
= window_left_x
+ area_width
;
5101 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5103 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5104 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
5110 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
5111 last_x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
5115 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
5116 area_width
= window_box_width (w
, area
);
5117 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
5120 /* Build a doubly-linked list of glyph_string structures between
5121 head and tail from what we have to draw. Note that the macro
5122 BUILD_GLYPH_STRINGS will modify its start parameter. That's
5123 the reason we use a separate variable `i'. */
5125 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
5128 x_reached
= tail
->x
+ tail
->background_width
;
5132 /* If there are any glyphs with lbearing < 0 or rbearing > width in
5133 the row, redraw some glyphs in front or following the glyph
5134 strings built above. */
5135 if (head
&& !overlaps_p
&& row
->contains_overlapping_glyphs_p
)
5138 struct glyph_string
*h
, *t
;
5140 /* Compute overhangs for all glyph strings. */
5141 for (s
= head
; s
; s
= s
->next
)
5142 x_compute_glyph_string_overhangs (s
);
5144 /* Prepend glyph strings for glyphs in front of the first glyph
5145 string that are overwritten because of the first glyph
5146 string's left overhang. The background of all strings
5147 prepended must be drawn because the first glyph string
5149 i
= x_left_overwritten (head
);
5153 BUILD_GLYPH_STRINGS (w
, row
, area
, j
, start
, h
, t
,
5154 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5158 *real_start
= start
;
5159 x_compute_overhangs_and_x (t
, head
->x
, 1);
5160 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5163 /* Prepend glyph strings for glyphs in front of the first glyph
5164 string that overwrite that glyph string because of their
5165 right overhang. For these strings, only the foreground must
5166 be drawn, because it draws over the glyph string at `head'.
5167 The background must not be drawn because this would overwrite
5168 right overhangs of preceding glyphs for which no glyph
5170 i
= x_left_overwriting (head
);
5173 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, start
, h
, t
,
5174 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5176 for (s
= h
; s
; s
= s
->next
)
5177 s
->background_filled_p
= 1;
5180 x_compute_overhangs_and_x (t
, head
->x
, 1);
5181 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5184 /* Append glyphs strings for glyphs following the last glyph
5185 string tail that are overwritten by tail. The background of
5186 these strings has to be drawn because tail's foreground draws
5188 i
= x_right_overwritten (tail
);
5191 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5192 DRAW_NORMAL_TEXT
, x
, last_x
,
5194 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5195 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5200 /* Append glyph strings for glyphs following the last glyph
5201 string tail that overwrite tail. The foreground of such
5202 glyphs has to be drawn because it writes into the background
5203 of tail. The background must not be drawn because it could
5204 paint over the foreground of following glyphs. */
5205 i
= x_right_overwriting (tail
);
5208 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5209 DRAW_NORMAL_TEXT
, x
, last_x
,
5211 for (s
= h
; s
; s
= s
->next
)
5212 s
->background_filled_p
= 1;
5213 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5214 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5220 /* Draw all strings. */
5221 for (s
= head
; s
; s
= s
->next
)
5222 x_draw_glyph_string (s
);
5224 /* Value is the x-position up to which drawn, relative to AREA of W.
5225 This doesn't include parts drawn because of overhangs. */
5226 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
5227 if (!row
->full_width_p
)
5229 if (area
> LEFT_MARGIN_AREA
)
5230 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5231 if (area
> TEXT_AREA
)
5232 x_reached
-= window_box_width (w
, TEXT_AREA
);
5239 /* Fix the display of area AREA of overlapping row ROW in window W. */
5242 x_fix_overlapping_area (w
, row
, area
)
5244 struct glyph_row
*row
;
5245 enum glyph_row_area area
;
5251 if (area
== LEFT_MARGIN_AREA
)
5253 else if (area
== TEXT_AREA
)
5254 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5256 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5257 + window_box_width (w
, TEXT_AREA
));
5259 for (i
= 0; i
< row
->used
[area
];)
5261 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
5263 int start
= i
, start_x
= x
;
5267 x
+= row
->glyphs
[area
][i
].pixel_width
;
5270 while (i
< row
->used
[area
]
5271 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5273 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5275 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5280 x
+= row
->glyphs
[area
][i
].pixel_width
;
5289 /* Output LEN glyphs starting at START at the nominal cursor position.
5290 Advance the nominal cursor over the text. The global variable
5291 updated_window contains the window being updated, updated_row is
5292 the glyph row being updated, and updated_area is the area of that
5293 row being updated. */
5296 x_write_glyphs (start
, len
)
5297 struct glyph
*start
;
5300 int x
, hpos
, real_start
, real_end
;
5302 xassert (updated_window
&& updated_row
);
5307 hpos
= start
- updated_row
->glyphs
[updated_area
];
5308 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5309 updated_row
, updated_area
,
5311 (updated_row
->inverse_p
5312 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5313 &real_start
, &real_end
, 0);
5315 /* If we drew over the cursor, note that it is not visible any more. */
5316 note_overwritten_text_cursor (updated_window
, real_start
,
5317 real_end
- real_start
);
5321 /* Advance the output cursor. */
5322 output_cursor
.hpos
+= len
;
5323 output_cursor
.x
= x
;
5327 /* Insert LEN glyphs from START at the nominal cursor position. */
5330 x_insert_glyphs (start
, len
)
5331 struct glyph
*start
;
5336 int line_height
, shift_by_width
, shifted_region_width
;
5337 struct glyph_row
*row
;
5338 struct glyph
*glyph
;
5339 int frame_x
, frame_y
, hpos
, real_start
, real_end
;
5341 xassert (updated_window
&& updated_row
);
5344 f
= XFRAME (WINDOW_FRAME (w
));
5346 /* Get the height of the line we are in. */
5348 line_height
= row
->height
;
5350 /* Get the width of the glyphs to insert. */
5352 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5353 shift_by_width
+= glyph
->pixel_width
;
5355 /* Get the width of the region to shift right. */
5356 shifted_region_width
= (window_box_width (w
, updated_area
)
5361 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
5362 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5363 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5364 f
->output_data
.x
->normal_gc
,
5366 shifted_region_width
, line_height
,
5367 frame_x
+ shift_by_width
, frame_y
);
5369 /* Write the glyphs. */
5370 hpos
= start
- row
->glyphs
[updated_area
];
5371 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5372 DRAW_NORMAL_TEXT
, &real_start
, &real_end
, 0);
5373 note_overwritten_text_cursor (w
, real_start
, real_end
- real_start
);
5375 /* Advance the output cursor. */
5376 output_cursor
.hpos
+= len
;
5377 output_cursor
.x
+= shift_by_width
;
5382 /* Delete N glyphs at the nominal cursor position. Not implemented
5393 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
5394 If they are <= 0, this is probably an error. */
5397 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
5404 xassert (width
> 0 && height
> 0);
5405 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
5409 /* Erase the current text line from the nominal cursor position
5410 (inclusive) to pixel column TO_X (exclusive). The idea is that
5411 everything from TO_X onward is already erased.
5413 TO_X is a pixel position relative to updated_area of
5414 updated_window. TO_X == -1 means clear to the end of this area. */
5417 x_clear_end_of_line (to_x
)
5421 struct window
*w
= updated_window
;
5422 int max_x
, min_y
, max_y
;
5423 int from_x
, from_y
, to_y
;
5425 xassert (updated_window
&& updated_row
);
5426 f
= XFRAME (w
->frame
);
5428 if (updated_row
->full_width_p
)
5430 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5431 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5432 && !w
->pseudo_window_p
)
5433 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5436 max_x
= window_box_width (w
, updated_area
);
5437 max_y
= window_text_bottom_y (w
);
5439 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5440 of window. For TO_X > 0, truncate to end of drawing area. */
5446 to_x
= min (to_x
, max_x
);
5448 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5450 /* Notice if the cursor will be cleared by this operation. */
5451 if (!updated_row
->full_width_p
)
5452 note_overwritten_text_cursor (w
, output_cursor
.hpos
, -1);
5454 from_x
= output_cursor
.x
;
5456 /* Translate to frame coordinates. */
5457 if (updated_row
->full_width_p
)
5459 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5460 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5464 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5465 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5468 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5469 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5470 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5472 /* Prevent inadvertently clearing to end of the X window. */
5473 if (to_x
> from_x
&& to_y
> from_y
)
5476 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5477 from_x
, from_y
, to_x
- from_x
, to_y
- from_y
,
5484 /* Clear entire frame. If updating_frame is non-null, clear that
5485 frame. Otherwise clear the selected frame. */
5495 f
= SELECTED_FRAME ();
5497 /* Clearing the frame will erase any cursor, so mark them all as no
5499 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5500 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5501 output_cursor
.x
= -1;
5503 /* We don't set the output cursor here because there will always
5504 follow an explicit cursor_to. */
5506 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5508 /* We have to clear the scroll bars, too. If we have changed
5509 colors or something like that, then they should be notified. */
5510 x_scroll_bar_clear (f
);
5512 XFlush (FRAME_X_DISPLAY (f
));
5518 /* Invert the middle quarter of the frame for .15 sec. */
5520 /* We use the select system call to do the waiting, so we have to make
5521 sure it's available. If it isn't, we just won't do visual bells. */
5523 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5526 /* Subtract the `struct timeval' values X and Y, storing the result in
5527 *RESULT. Return 1 if the difference is negative, otherwise 0. */
5530 timeval_subtract (result
, x
, y
)
5531 struct timeval
*result
, x
, y
;
5533 /* Perform the carry for the later subtraction by updating y. This
5534 is safer because on some systems the tv_sec member is unsigned. */
5535 if (x
.tv_usec
< y
.tv_usec
)
5537 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
5538 y
.tv_usec
-= 1000000 * nsec
;
5542 if (x
.tv_usec
- y
.tv_usec
> 1000000)
5544 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
5545 y
.tv_usec
+= 1000000 * nsec
;
5549 /* Compute the time remaining to wait. tv_usec is certainly
5551 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
5552 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
5554 /* Return indication of whether the result should be considered
5556 return x
.tv_sec
< y
.tv_sec
;
5568 /* Create a GC that will use the GXxor function to flip foreground
5569 pixels into background pixels. */
5573 values
.function
= GXxor
;
5574 values
.foreground
= (f
->output_data
.x
->foreground_pixel
5575 ^ f
->output_data
.x
->background_pixel
);
5577 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5578 GCFunction
| GCForeground
, &values
);
5582 /* Get the height not including a menu bar widget. */
5583 int height
= CHAR_TO_PIXEL_HEIGHT (f
, FRAME_HEIGHT (f
));
5584 /* Height of each line to flash. */
5585 int flash_height
= FRAME_LINE_HEIGHT (f
);
5586 /* These will be the left and right margins of the rectangles. */
5587 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
5588 int flash_right
= PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
5592 /* Don't flash the area between a scroll bar and the frame
5593 edge it is next to. */
5594 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
5596 case vertical_scroll_bar_left
:
5597 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5600 case vertical_scroll_bar_right
:
5601 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5608 width
= flash_right
- flash_left
;
5610 /* If window is tall, flash top and bottom line. */
5611 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5613 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5615 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5616 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5617 width
, flash_height
);
5618 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5620 (height
- flash_height
5621 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5622 width
, flash_height
);
5625 /* If it is short, flash it all. */
5626 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5627 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5628 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5633 struct timeval wakeup
;
5635 EMACS_GET_TIME (wakeup
);
5637 /* Compute time to wait until, propagating carry from usecs. */
5638 wakeup
.tv_usec
+= 150000;
5639 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
5640 wakeup
.tv_usec
%= 1000000;
5642 /* Keep waiting until past the time wakeup or any input gets
5644 while (! detect_input_pending ())
5646 struct timeval current
;
5647 struct timeval timeout
;
5649 EMACS_GET_TIME (current
);
5651 /* Break if result would be negative. */
5652 if (timeval_subtract (¤t
, wakeup
, current
))
5655 /* How long `select' should wait. */
5657 timeout
.tv_usec
= 10000;
5659 /* Try to wait that long--but we might wake up sooner. */
5660 select (0, NULL
, NULL
, NULL
, &timeout
);
5664 /* If window is tall, flash top and bottom line. */
5665 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5667 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5669 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5670 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5671 width
, flash_height
);
5672 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5674 (height
- flash_height
5675 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5676 width
, flash_height
);
5679 /* If it is short, flash it all. */
5680 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5681 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5682 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5684 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5692 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5695 /* Make audible bell. */
5700 struct frame
*f
= SELECTED_FRAME ();
5702 if (FRAME_X_DISPLAY (f
))
5704 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5711 XBell (FRAME_X_DISPLAY (f
), 0);
5712 XFlush (FRAME_X_DISPLAY (f
));
5719 /* Specify how many text lines, from the top of the window,
5720 should be affected by insert-lines and delete-lines operations.
5721 This, and those operations, are used only within an update
5722 that is bounded by calls to x_update_begin and x_update_end. */
5725 XTset_terminal_window (n
)
5728 /* This function intentionally left blank. */
5733 /***********************************************************************
5735 ***********************************************************************/
5737 /* Perform an insert-lines or delete-lines operation, inserting N
5738 lines or deleting -N lines at vertical position VPOS. */
5741 x_ins_del_lines (vpos
, n
)
5748 /* Scroll part of the display as described by RUN. */
5751 x_scroll_run (w
, run
)
5755 struct frame
*f
= XFRAME (w
->frame
);
5756 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5758 /* Get frame-relative bounding box of the text display area of W,
5759 without mode lines. Include in this box the flags areas to the
5760 left and right of W. */
5761 window_box (w
, -1, &x
, &y
, &width
, &height
);
5762 width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
5763 x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
5765 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5766 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5767 bottom_y
= y
+ height
;
5771 /* Scrolling up. Make sure we don't copy part of the mode
5772 line at the bottom. */
5773 if (from_y
+ run
->height
> bottom_y
)
5774 height
= bottom_y
- from_y
;
5776 height
= run
->height
;
5780 /* Scolling down. Make sure we don't copy over the mode line.
5782 if (to_y
+ run
->height
> bottom_y
)
5783 height
= bottom_y
- to_y
;
5785 height
= run
->height
;
5790 /* Cursor off. Will be switched on again in x_update_window_end. */
5794 XCopyArea (FRAME_X_DISPLAY (f
),
5795 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5796 f
->output_data
.x
->normal_gc
,
5806 /***********************************************************************
5808 ***********************************************************************/
5810 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5811 corner of the exposed rectangle. W and H are width and height of
5812 the exposed area. All are pixel values. W or H zero means redraw
5813 the entire frame. */
5816 expose_frame (f
, x
, y
, w
, h
)
5821 int mouse_face_overwritten_p
= 0;
5823 TRACE ((stderr
, "expose_frame "));
5825 /* No need to redraw if frame will be redrawn soon. */
5826 if (FRAME_GARBAGED_P (f
))
5828 TRACE ((stderr
, " garbaged\n"));
5832 /* If basic faces haven't been realized yet, there is no point in
5833 trying to redraw anything. This can happen when we get an expose
5834 event while Emacs is starting, e.g. by moving another window. */
5835 if (FRAME_FACE_CACHE (f
) == NULL
5836 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5838 TRACE ((stderr
, " no faces\n"));
5842 if (w
== 0 || h
== 0)
5845 r
.width
= CANON_X_UNIT (f
) * f
->width
;
5846 r
.height
= CANON_Y_UNIT (f
) * f
->height
;
5856 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
5857 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
5859 if (WINDOWP (f
->tool_bar_window
))
5860 mouse_face_overwritten_p
5861 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
5863 #ifndef USE_X_TOOLKIT
5864 if (WINDOWP (f
->menu_bar_window
))
5865 mouse_face_overwritten_p
5866 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
5867 #endif /* not USE_X_TOOLKIT */
5869 /* Some window managers support a focus-follows-mouse style with
5870 delayed raising of frames. Imagine a partially obscured frame,
5871 and moving the mouse into partially obscured mouse-face on that
5872 frame. The visible part of the mouse-face will be highlighted,
5873 then the WM raises the obscured frame. With at least one WM, KDE
5874 2.1, Emacs is not getting any event for the raising of the frame
5875 (even tried with SubstructureRedirectMask), only Expose events.
5876 These expose events will draw text normally, i.e. not
5877 highlighted. Which means we must redo the highlight here.
5878 Subsume it under ``we love X''. --gerd 2001-08-15 */
5879 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
5881 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5882 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5884 int x
= dpyinfo
->mouse_face_mouse_x
;
5885 int y
= dpyinfo
->mouse_face_mouse_y
;
5886 clear_mouse_face (dpyinfo
);
5887 note_mouse_highlight (f
, x
, y
);
5893 /* Redraw (parts) of all windows in the window tree rooted at W that
5894 intersect R. R contains frame pixel coordinates. Value is
5895 non-zero if the exposure overwrites mouse-face. */
5898 expose_window_tree (w
, r
)
5902 struct frame
*f
= XFRAME (w
->frame
);
5903 int mouse_face_overwritten_p
= 0;
5905 while (w
&& !FRAME_GARBAGED_P (f
))
5907 if (!NILP (w
->hchild
))
5908 mouse_face_overwritten_p
5909 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
5910 else if (!NILP (w
->vchild
))
5911 mouse_face_overwritten_p
5912 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
5914 mouse_face_overwritten_p
|= expose_window (w
, r
);
5916 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
5919 return mouse_face_overwritten_p
;
5923 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5924 which intersects rectangle R. R is in window-relative coordinates. */
5927 expose_area (w
, row
, r
, area
)
5929 struct glyph_row
*row
;
5931 enum glyph_row_area area
;
5933 struct glyph
*first
= row
->glyphs
[area
];
5934 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5936 int first_x
, start_x
, x
;
5938 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5939 /* If row extends face to end of line write the whole line. */
5940 x_draw_glyphs (w
, 0, row
, area
,
5942 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5946 /* Set START_X to the window-relative start position for drawing glyphs of
5947 AREA. The first glyph of the text area can be partially visible.
5948 The first glyphs of other areas cannot. */
5949 if (area
== LEFT_MARGIN_AREA
)
5951 else if (area
== TEXT_AREA
)
5952 start_x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5954 start_x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5955 + window_box_width (w
, TEXT_AREA
));
5958 /* Find the first glyph that must be redrawn. */
5960 && x
+ first
->pixel_width
< r
->x
)
5962 x
+= first
->pixel_width
;
5966 /* Find the last one. */
5970 && x
< r
->x
+ r
->width
)
5972 x
+= last
->pixel_width
;
5978 x_draw_glyphs (w
, first_x
- start_x
, row
, area
,
5979 first
- row
->glyphs
[area
],
5980 last
- row
->glyphs
[area
],
5981 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5987 /* Redraw the parts of the glyph row ROW on window W intersecting
5988 rectangle R. R is in window-relative coordinates. Value is
5989 non-zero if mouse-face was overwritten. */
5992 expose_line (w
, row
, r
)
5994 struct glyph_row
*row
;
5997 xassert (row
->enabled_p
);
5999 if (row
->mode_line_p
|| w
->pseudo_window_p
)
6000 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
6001 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
6005 if (row
->used
[LEFT_MARGIN_AREA
])
6006 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
6007 if (row
->used
[TEXT_AREA
])
6008 expose_area (w
, row
, r
, TEXT_AREA
);
6009 if (row
->used
[RIGHT_MARGIN_AREA
])
6010 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
6011 x_draw_row_bitmaps (w
, row
);
6014 return row
->mouse_face_p
;
6018 /* Return non-zero if W's cursor intersects rectangle R. */
6021 x_phys_cursor_in_rect_p (w
, r
)
6025 XRectangle cr
, result
;
6026 struct glyph
*cursor_glyph
;
6028 cursor_glyph
= get_phys_cursor_glyph (w
);
6031 cr
.x
= w
->phys_cursor
.x
;
6032 cr
.y
= w
->phys_cursor
.y
;
6033 cr
.width
= cursor_glyph
->pixel_width
;
6034 cr
.height
= w
->phys_cursor_height
;
6035 return x_intersect_rectangles (&cr
, r
, &result
);
6042 /* Redraw the part of window W intersection rectangle FR. Pixel
6043 coordinates in FR are frame-relative. Call this function with
6044 input blocked. Value is non-zero if the exposure overwrites
6048 expose_window (w
, fr
)
6052 struct frame
*f
= XFRAME (w
->frame
);
6054 int mouse_face_overwritten_p
= 0;
6056 /* If window is not yet fully initialized, do nothing. This can
6057 happen when toolkit scroll bars are used and a window is split.
6058 Reconfiguring the scroll bar will generate an expose for a newly
6060 if (w
->current_matrix
== NULL
)
6063 /* When we're currently updating the window, display and current
6064 matrix usually don't agree. Arrange for a thorough display
6066 if (w
== updated_window
)
6068 SET_FRAME_GARBAGED (f
);
6072 /* Frame-relative pixel rectangle of W. */
6073 wr
.x
= XFASTINT (w
->left
) * CANON_X_UNIT (f
);
6074 wr
.y
= XFASTINT (w
->top
) * CANON_Y_UNIT (f
);
6075 wr
.width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
6076 wr
.height
= XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
6078 if (x_intersect_rectangles (fr
, &wr
, &r
))
6080 int yb
= window_text_bottom_y (w
);
6081 struct glyph_row
*row
;
6082 int cursor_cleared_p
;
6084 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
6085 r
.x
, r
.y
, r
.width
, r
.height
));
6087 /* Convert to window coordinates. */
6088 r
.x
= FRAME_TO_WINDOW_PIXEL_X (w
, r
.x
);
6089 r
.y
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
.y
);
6091 /* Turn off the cursor. */
6092 if (!w
->pseudo_window_p
6093 && x_phys_cursor_in_rect_p (w
, &r
))
6096 cursor_cleared_p
= 1;
6099 cursor_cleared_p
= 0;
6101 /* Find the first row intersecting the rectangle R. */
6102 for (row
= w
->current_matrix
->rows
;
6107 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
6109 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
6110 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
6111 || (r
.y
>= y0
&& r
.y
< y1
)
6112 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
6114 if (expose_line (w
, row
, &r
))
6115 mouse_face_overwritten_p
= 1;
6122 /* Display the mode line if there is one. */
6123 if (WINDOW_WANTS_MODELINE_P (w
)
6124 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
6126 && row
->y
< r
.y
+ r
.height
)
6128 if (expose_line (w
, row
, &r
))
6129 mouse_face_overwritten_p
= 1;
6132 if (!w
->pseudo_window_p
)
6134 /* Draw border between windows. */
6135 x_draw_vertical_border (w
);
6137 /* Turn the cursor on again. */
6138 if (cursor_cleared_p
)
6139 x_update_window_cursor (w
, 1);
6143 return mouse_face_overwritten_p
;
6147 /* Determine the intersection of two rectangles R1 and R2. Return
6148 the intersection in *RESULT. Value is non-zero if RESULT is not
6152 x_intersect_rectangles (r1
, r2
, result
)
6153 XRectangle
*r1
, *r2
, *result
;
6155 XRectangle
*left
, *right
;
6156 XRectangle
*upper
, *lower
;
6157 int intersection_p
= 0;
6159 /* Rearrange so that R1 is the left-most rectangle. */
6161 left
= r1
, right
= r2
;
6163 left
= r2
, right
= r1
;
6165 /* X0 of the intersection is right.x0, if this is inside R1,
6166 otherwise there is no intersection. */
6167 if (right
->x
<= left
->x
+ left
->width
)
6169 result
->x
= right
->x
;
6171 /* The right end of the intersection is the minimum of the
6172 the right ends of left and right. */
6173 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
6176 /* Same game for Y. */
6178 upper
= r1
, lower
= r2
;
6180 upper
= r2
, lower
= r1
;
6182 /* The upper end of the intersection is lower.y0, if this is inside
6183 of upper. Otherwise, there is no intersection. */
6184 if (lower
->y
<= upper
->y
+ upper
->height
)
6186 result
->y
= lower
->y
;
6188 /* The lower end of the intersection is the minimum of the lower
6189 ends of upper and lower. */
6190 result
->height
= (min (lower
->y
+ lower
->height
,
6191 upper
->y
+ upper
->height
)
6197 return intersection_p
;
6208 /* We used to only do this if Vx_no_window_manager was non-nil, but
6209 the ICCCM (section 4.1.6) says that the window's border pixmap
6210 and border pixel are window attributes which are "private to the
6211 client", so we can always change it to whatever we want. */
6213 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6214 f
->output_data
.x
->border_pixel
);
6216 x_update_cursor (f
, 1);
6220 frame_unhighlight (f
)
6223 /* We used to only do this if Vx_no_window_manager was non-nil, but
6224 the ICCCM (section 4.1.6) says that the window's border pixmap
6225 and border pixel are window attributes which are "private to the
6226 client", so we can always change it to whatever we want. */
6228 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6229 f
->output_data
.x
->border_tile
);
6231 x_update_cursor (f
, 1);
6234 /* The focus has changed. Update the frames as necessary to reflect
6235 the new situation. Note that we can't change the selected frame
6236 here, because the Lisp code we are interrupting might become confused.
6237 Each event gets marked with the frame in which it occurred, so the
6238 Lisp code can tell when the switch took place by examining the events. */
6241 x_new_focus_frame (dpyinfo
, frame
)
6242 struct x_display_info
*dpyinfo
;
6243 struct frame
*frame
;
6245 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
6247 if (frame
!= dpyinfo
->x_focus_frame
)
6249 /* Set this before calling other routines, so that they see
6250 the correct value of x_focus_frame. */
6251 dpyinfo
->x_focus_frame
= frame
;
6253 if (old_focus
&& old_focus
->auto_lower
)
6254 x_lower_frame (old_focus
);
6257 selected_frame
= frame
;
6258 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
6260 Fselect_window (selected_frame
->selected_window
);
6261 choose_minibuf_frame ();
6264 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
6265 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
6267 pending_autoraise_frame
= 0;
6270 x_frame_rehighlight (dpyinfo
);
6273 /* Handle an event saying the mouse has moved out of an Emacs frame. */
6276 x_mouse_leave (dpyinfo
)
6277 struct x_display_info
*dpyinfo
;
6279 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
6282 /* The focus has changed, or we have redirected a frame's focus to
6283 another frame (this happens when a frame uses a surrogate
6284 mini-buffer frame). Shift the highlight as appropriate.
6286 The FRAME argument doesn't necessarily have anything to do with which
6287 frame is being highlighted or un-highlighted; we only use it to find
6288 the appropriate X display info. */
6291 XTframe_rehighlight (frame
)
6292 struct frame
*frame
;
6294 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
6298 x_frame_rehighlight (dpyinfo
)
6299 struct x_display_info
*dpyinfo
;
6301 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
6303 if (dpyinfo
->x_focus_frame
)
6305 dpyinfo
->x_highlight_frame
6306 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
6307 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
6308 : dpyinfo
->x_focus_frame
);
6309 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
6311 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
6312 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
6316 dpyinfo
->x_highlight_frame
= 0;
6318 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
6321 frame_unhighlight (old_highlight
);
6322 if (dpyinfo
->x_highlight_frame
)
6323 frame_highlight (dpyinfo
->x_highlight_frame
);
6329 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
6331 /* Initialize mode_switch_bit and modifier_meaning. */
6333 x_find_modifier_meanings (dpyinfo
)
6334 struct x_display_info
*dpyinfo
;
6336 int min_code
, max_code
;
6339 XModifierKeymap
*mods
;
6341 dpyinfo
->meta_mod_mask
= 0;
6342 dpyinfo
->shift_lock_mask
= 0;
6343 dpyinfo
->alt_mod_mask
= 0;
6344 dpyinfo
->super_mod_mask
= 0;
6345 dpyinfo
->hyper_mod_mask
= 0;
6348 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
6350 min_code
= dpyinfo
->display
->min_keycode
;
6351 max_code
= dpyinfo
->display
->max_keycode
;
6354 syms
= XGetKeyboardMapping (dpyinfo
->display
,
6355 min_code
, max_code
- min_code
+ 1,
6357 mods
= XGetModifierMapping (dpyinfo
->display
);
6359 /* Scan the modifier table to see which modifier bits the Meta and
6360 Alt keysyms are on. */
6362 int row
, col
; /* The row and column in the modifier table. */
6364 for (row
= 3; row
< 8; row
++)
6365 for (col
= 0; col
< mods
->max_keypermod
; col
++)
6368 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
6370 /* Zeroes are used for filler. Skip them. */
6374 /* Are any of this keycode's keysyms a meta key? */
6378 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
6380 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
6386 dpyinfo
->meta_mod_mask
|= (1 << row
);
6391 dpyinfo
->alt_mod_mask
|= (1 << row
);
6396 dpyinfo
->hyper_mod_mask
|= (1 << row
);
6401 dpyinfo
->super_mod_mask
|= (1 << row
);
6405 /* Ignore this if it's not on the lock modifier. */
6406 if ((1 << row
) == LockMask
)
6407 dpyinfo
->shift_lock_mask
= LockMask
;
6415 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
6416 if (! dpyinfo
->meta_mod_mask
)
6418 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
6419 dpyinfo
->alt_mod_mask
= 0;
6422 /* If some keys are both alt and meta,
6423 make them just meta, not alt. */
6424 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
6426 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
6429 XFree ((char *) syms
);
6430 XFreeModifiermap (mods
);
6433 /* Convert between the modifier bits X uses and the modifier bits
6437 x_x_to_emacs_modifiers (dpyinfo
, state
)
6438 struct x_display_info
*dpyinfo
;
6441 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
6442 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
6443 | ((state
& dpyinfo
->meta_mod_mask
) ? meta_modifier
: 0)
6444 | ((state
& dpyinfo
->alt_mod_mask
) ? alt_modifier
: 0)
6445 | ((state
& dpyinfo
->super_mod_mask
) ? super_modifier
: 0)
6446 | ((state
& dpyinfo
->hyper_mod_mask
) ? hyper_modifier
: 0));
6450 x_emacs_to_x_modifiers (dpyinfo
, state
)
6451 struct x_display_info
*dpyinfo
;
6454 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
6455 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
6456 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
6457 | ((state
& shift_modifier
) ? ShiftMask
: 0)
6458 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
6459 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
6462 /* Convert a keysym to its name. */
6465 x_get_keysym_name (keysym
)
6471 value
= XKeysymToString (keysym
);
6479 /* Mouse clicks and mouse movement. Rah. */
6481 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6482 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6483 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6484 not force the value into range. */
6487 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
6489 register int pix_x
, pix_y
;
6490 register int *x
, *y
;
6494 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6495 even for negative values. */
6497 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
6499 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
6501 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
6502 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
6506 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
6507 bounds
->height
= f
->output_data
.x
->line_height
;
6508 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
6509 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
6516 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
6517 pix_x
= FRAME_WINDOW_WIDTH (f
);
6521 else if (pix_y
> f
->height
)
6530 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6531 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6532 can't tell the positions because W's display is not up to date,
6536 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
6539 int *frame_x
, *frame_y
;
6543 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
6544 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
6546 if (display_completed
)
6548 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6549 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
6550 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
6556 *frame_x
+= glyph
->pixel_width
;
6564 *frame_y
= *frame_x
= 0;
6568 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6569 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6574 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6576 If the event is a button press, then note that we have grabbed
6580 construct_mouse_click (result
, event
, f
)
6581 struct input_event
*result
;
6582 XButtonEvent
*event
;
6585 /* Make the event type no_event; we'll change that when we decide
6587 result
->kind
= mouse_click
;
6588 result
->code
= event
->button
- Button1
;
6589 result
->timestamp
= event
->time
;
6590 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6592 | (event
->type
== ButtonRelease
6596 XSETINT (result
->x
, event
->x
);
6597 XSETINT (result
->y
, event
->y
);
6598 XSETFRAME (result
->frame_or_window
, f
);
6604 /* Function to report a mouse movement to the mainstream Emacs code.
6605 The input handler calls this.
6607 We have received a mouse movement event, which is given in *event.
6608 If the mouse is over a different glyph than it was last time, tell
6609 the mainstream emacs code by setting mouse_moved. If not, ask for
6610 another motion event, so we can check again the next time it moves. */
6612 static XMotionEvent last_mouse_motion_event
;
6613 static Lisp_Object last_mouse_motion_frame
;
6616 note_mouse_movement (frame
, event
)
6618 XMotionEvent
*event
;
6620 last_mouse_movement_time
= event
->time
;
6621 last_mouse_motion_event
= *event
;
6622 XSETFRAME (last_mouse_motion_frame
, frame
);
6624 if (event
->window
!= FRAME_X_WINDOW (frame
))
6626 frame
->mouse_moved
= 1;
6627 last_mouse_scroll_bar
= Qnil
;
6628 note_mouse_highlight (frame
, -1, -1);
6631 /* Has the mouse moved off the glyph it was on at the last sighting? */
6632 else if (event
->x
< last_mouse_glyph
.x
6633 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
6634 || event
->y
< last_mouse_glyph
.y
6635 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
6637 frame
->mouse_moved
= 1;
6638 last_mouse_scroll_bar
= Qnil
;
6639 note_mouse_highlight (frame
, event
->x
, event
->y
);
6643 /* This is used for debugging, to turn off note_mouse_highlight. */
6645 int disable_mouse_highlight
;
6649 /************************************************************************
6651 ************************************************************************/
6653 /* Find the glyph under window-relative coordinates X/Y in window W.
6654 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6655 strings. Return in *HPOS and *VPOS the row and column number of
6656 the glyph found. Return in *AREA the glyph area containing X.
6657 Value is a pointer to the glyph found or null if X/Y is not on
6658 text, or we can't tell because W's current matrix is not up to
6661 static struct glyph
*
6662 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
, buffer_only_p
)
6665 int *hpos
, *vpos
, *area
;
6668 struct glyph
*glyph
, *end
;
6669 struct glyph_row
*row
= NULL
;
6670 int x0
, i
, left_area_width
;
6672 /* Find row containing Y. Give up if some row is not enabled. */
6673 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6675 row
= MATRIX_ROW (w
->current_matrix
, i
);
6676 if (!row
->enabled_p
)
6678 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6685 /* Give up if Y is not in the window. */
6686 if (i
== w
->current_matrix
->nrows
)
6689 /* Get the glyph area containing X. */
6690 if (w
->pseudo_window_p
)
6697 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6698 if (x
< left_area_width
)
6700 *area
= LEFT_MARGIN_AREA
;
6703 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6706 x0
= row
->x
+ left_area_width
;
6710 *area
= RIGHT_MARGIN_AREA
;
6711 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6715 /* Find glyph containing X. */
6716 glyph
= row
->glyphs
[*area
];
6717 end
= glyph
+ row
->used
[*area
];
6720 if (x
< x0
+ glyph
->pixel_width
)
6722 if (w
->pseudo_window_p
)
6724 else if (!buffer_only_p
|| BUFFERP (glyph
->object
))
6728 x0
+= glyph
->pixel_width
;
6735 *hpos
= glyph
- row
->glyphs
[*area
];
6740 /* Convert frame-relative x/y to coordinates relative to window W.
6741 Takes pseudo-windows into account. */
6744 frame_to_window_pixel_xy (w
, x
, y
)
6748 if (w
->pseudo_window_p
)
6750 /* A pseudo-window is always full-width, and starts at the
6751 left edge of the frame, plus a frame border. */
6752 struct frame
*f
= XFRAME (w
->frame
);
6753 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6754 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6758 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6759 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6764 /* Take proper action when mouse has moved to the mode or header line of
6765 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6766 mode line. X is relative to the start of the text display area of
6767 W, so the width of bitmap areas and scroll bars must be subtracted
6768 to get a position relative to the start of the mode line. */
6771 note_mode_line_highlight (w
, x
, mode_line_p
)
6775 struct frame
*f
= XFRAME (w
->frame
);
6776 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6777 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6778 struct glyph_row
*row
;
6781 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6783 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6787 struct glyph
*glyph
, *end
;
6788 Lisp_Object help
, map
;
6791 /* Find the glyph under X. */
6792 glyph
= row
->glyphs
[TEXT_AREA
];
6793 end
= glyph
+ row
->used
[TEXT_AREA
];
6794 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6795 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
));
6798 && x
>= x0
+ glyph
->pixel_width
)
6800 x0
+= glyph
->pixel_width
;
6805 && STRINGP (glyph
->object
)
6806 && XSTRING (glyph
->object
)->intervals
6807 && glyph
->charpos
>= 0
6808 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6810 /* If we're on a string with `help-echo' text property,
6811 arrange for the help to be displayed. This is done by
6812 setting the global variable help_echo to the help string. */
6813 help
= Fget_text_property (make_number (glyph
->charpos
),
6814 Qhelp_echo
, glyph
->object
);
6818 XSETWINDOW (help_echo_window
, w
);
6819 help_echo_object
= glyph
->object
;
6820 help_echo_pos
= glyph
->charpos
;
6823 /* Change the mouse pointer according to what is under X/Y. */
6824 map
= Fget_text_property (make_number (glyph
->charpos
),
6825 Qlocal_map
, glyph
->object
);
6827 cursor
= f
->output_data
.x
->nontext_cursor
;
6830 map
= Fget_text_property (make_number (glyph
->charpos
),
6831 Qkeymap
, glyph
->object
);
6833 cursor
= f
->output_data
.x
->nontext_cursor
;
6838 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6842 /* Take proper action when the mouse has moved to position X, Y on
6843 frame F as regards highlighting characters that have mouse-face
6844 properties. Also de-highlighting chars where the mouse was before.
6845 X and Y can be negative or out of range. */
6848 note_mouse_highlight (f
, x
, y
)
6852 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6856 Cursor cursor
= None
;
6859 /* When a menu is active, don't highlight because this looks odd. */
6860 #ifdef USE_X_TOOLKIT
6861 if (popup_activated ())
6865 if (disable_mouse_highlight
6866 || !f
->glyphs_initialized_p
)
6869 dpyinfo
->mouse_face_mouse_x
= x
;
6870 dpyinfo
->mouse_face_mouse_y
= y
;
6871 dpyinfo
->mouse_face_mouse_frame
= f
;
6873 if (dpyinfo
->mouse_face_defer
)
6878 dpyinfo
->mouse_face_deferred_gc
= 1;
6882 /* Which window is that in? */
6883 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6885 /* If we were displaying active text in another window, clear that. */
6886 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6887 clear_mouse_face (dpyinfo
);
6889 /* Not on a window -> return. */
6890 if (!WINDOWP (window
))
6893 /* Convert to window-relative pixel coordinates. */
6894 w
= XWINDOW (window
);
6895 frame_to_window_pixel_xy (w
, &x
, &y
);
6897 /* Handle tool-bar window differently since it doesn't display a
6899 if (EQ (window
, f
->tool_bar_window
))
6901 note_tool_bar_highlight (f
, x
, y
);
6905 /* Mouse is on the mode or header line? */
6906 if (portion
== 1 || portion
== 3)
6908 note_mode_line_highlight (w
, x
, portion
== 1);
6913 cursor
= f
->output_data
.x
->horizontal_drag_cursor
;
6915 cursor
= f
->output_data
.x
->text_cursor
;
6917 /* Are we in a window whose display is up to date?
6918 And verify the buffer's text has not changed. */
6919 b
= XBUFFER (w
->buffer
);
6920 if (/* Within text portion of the window. */
6922 && EQ (w
->window_end_valid
, w
->buffer
)
6923 && XFASTINT (w
->last_modified
) == BUF_MODIFF (b
)
6924 && XFASTINT (w
->last_overlay_modified
) == BUF_OVERLAY_MODIFF (b
))
6926 int hpos
, vpos
, pos
, i
, area
;
6927 struct glyph
*glyph
;
6929 Lisp_Object mouse_face
= Qnil
, overlay
= Qnil
, position
;
6930 Lisp_Object
*overlay_vec
= NULL
;
6932 struct buffer
*obuf
;
6933 int obegv
, ozv
, same_region
;
6935 /* Find the glyph under X/Y. */
6936 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
, 0);
6938 /* Clear mouse face if X/Y not over text. */
6940 || area
!= TEXT_AREA
6941 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6943 if (clear_mouse_face (dpyinfo
))
6948 pos
= glyph
->charpos
;
6949 object
= glyph
->object
;
6950 if (!STRINGP (object
) && !BUFFERP (object
))
6953 /* If we get an out-of-range value, return now; avoid an error. */
6954 if (BUFFERP (object
) && pos
> BUF_Z (b
))
6957 /* Make the window's buffer temporarily current for
6958 overlays_at and compute_char_face. */
6959 obuf
= current_buffer
;
6966 /* Is this char mouse-active or does it have help-echo? */
6967 position
= make_number (pos
);
6969 if (BUFFERP (object
))
6971 /* Put all the overlays we want in a vector in overlay_vec.
6972 Store the length in len. If there are more than 10, make
6973 enough space for all, and try again. */
6975 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6976 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
6977 if (noverlays
> len
)
6980 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6981 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
,0);
6984 /* Sort overlays into increasing priority order. */
6985 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6990 same_region
= (EQ (window
, dpyinfo
->mouse_face_window
)
6991 && vpos
>= dpyinfo
->mouse_face_beg_row
6992 && vpos
<= dpyinfo
->mouse_face_end_row
6993 && (vpos
> dpyinfo
->mouse_face_beg_row
6994 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6995 && (vpos
< dpyinfo
->mouse_face_end_row
6996 || hpos
< dpyinfo
->mouse_face_end_col
6997 || dpyinfo
->mouse_face_past_end
));
7002 /* Check mouse-face highlighting. */
7004 /* If there exists an overlay with mouse-face overlapping
7005 the one we are currently highlighting, we have to
7006 check if we enter the overlapping overlay, and then
7007 highlight only that. */
7008 || (OVERLAYP (dpyinfo
->mouse_face_overlay
)
7009 && mouse_face_overlay_overlaps (dpyinfo
->mouse_face_overlay
)))
7011 /* Find the highest priority overlay that has a mouse-face
7014 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
7016 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
7017 if (!NILP (mouse_face
))
7018 overlay
= overlay_vec
[i
];
7021 /* If we're actually highlighting the same overlay as
7022 before, there's no need to do that again. */
7024 && EQ (overlay
, dpyinfo
->mouse_face_overlay
))
7025 goto check_help_echo
;
7027 dpyinfo
->mouse_face_overlay
= overlay
;
7029 /* Clear the display of the old active region, if any. */
7030 if (clear_mouse_face (dpyinfo
))
7033 /* If no overlay applies, get a text property. */
7035 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
7037 /* Handle the overlay case. */
7038 if (!NILP (overlay
))
7040 /* Find the range of text around this char that
7041 should be active. */
7042 Lisp_Object before
, after
;
7045 before
= Foverlay_start (overlay
);
7046 after
= Foverlay_end (overlay
);
7047 /* Record this as the current active region. */
7048 fast_find_position (w
, XFASTINT (before
),
7049 &dpyinfo
->mouse_face_beg_col
,
7050 &dpyinfo
->mouse_face_beg_row
,
7051 &dpyinfo
->mouse_face_beg_x
,
7052 &dpyinfo
->mouse_face_beg_y
);
7053 dpyinfo
->mouse_face_past_end
7054 = !fast_find_position (w
, XFASTINT (after
),
7055 &dpyinfo
->mouse_face_end_col
,
7056 &dpyinfo
->mouse_face_end_row
,
7057 &dpyinfo
->mouse_face_end_x
,
7058 &dpyinfo
->mouse_face_end_y
);
7059 dpyinfo
->mouse_face_window
= window
;
7060 dpyinfo
->mouse_face_face_id
7061 = face_at_buffer_position (w
, pos
, 0, 0,
7062 &ignore
, pos
+ 1, 1);
7064 /* Display it as active. */
7065 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7068 /* Handle the text property case. */
7069 else if (!NILP (mouse_face
) && BUFFERP (object
))
7071 /* Find the range of text around this char that
7072 should be active. */
7073 Lisp_Object before
, after
, beginning
, end
;
7076 beginning
= Fmarker_position (w
->start
);
7077 end
= make_number (BUF_Z (XBUFFER (object
))
7078 - XFASTINT (w
->window_end_pos
));
7080 = Fprevious_single_property_change (make_number (pos
+ 1),
7084 = Fnext_single_property_change (position
, Qmouse_face
,
7087 /* Record this as the current active region. */
7088 fast_find_position (w
, XFASTINT (before
),
7089 &dpyinfo
->mouse_face_beg_col
,
7090 &dpyinfo
->mouse_face_beg_row
,
7091 &dpyinfo
->mouse_face_beg_x
,
7092 &dpyinfo
->mouse_face_beg_y
);
7093 dpyinfo
->mouse_face_past_end
7094 = !fast_find_position (w
, XFASTINT (after
),
7095 &dpyinfo
->mouse_face_end_col
,
7096 &dpyinfo
->mouse_face_end_row
,
7097 &dpyinfo
->mouse_face_end_x
,
7098 &dpyinfo
->mouse_face_end_y
);
7099 dpyinfo
->mouse_face_window
= window
;
7101 if (BUFFERP (object
))
7102 dpyinfo
->mouse_face_face_id
7103 = face_at_buffer_position (w
, pos
, 0, 0,
7104 &ignore
, pos
+ 1, 1);
7106 /* Display it as active. */
7107 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7110 else if (!NILP (mouse_face
) && STRINGP (object
))
7115 b
= Fprevious_single_property_change (make_number (pos
+ 1),
7118 e
= Fnext_single_property_change (position
, Qmouse_face
,
7121 b
= make_number (0);
7123 e
= make_number (XSTRING (object
)->size
- 1);
7124 fast_find_string_pos (w
, XINT (b
), object
,
7125 &dpyinfo
->mouse_face_beg_col
,
7126 &dpyinfo
->mouse_face_beg_row
,
7127 &dpyinfo
->mouse_face_beg_x
,
7128 &dpyinfo
->mouse_face_beg_y
, 0);
7129 fast_find_string_pos (w
, XINT (e
), object
,
7130 &dpyinfo
->mouse_face_end_col
,
7131 &dpyinfo
->mouse_face_end_row
,
7132 &dpyinfo
->mouse_face_end_x
,
7133 &dpyinfo
->mouse_face_end_y
, 1);
7134 dpyinfo
->mouse_face_past_end
= 0;
7135 dpyinfo
->mouse_face_window
= window
;
7136 dpyinfo
->mouse_face_face_id
7137 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
7139 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7146 /* Look for a `help-echo' property. */
7148 Lisp_Object help
, overlay
;
7150 /* Check overlays first. */
7151 help
= overlay
= Qnil
;
7152 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
7154 overlay
= overlay_vec
[i
];
7155 help
= Foverlay_get (overlay
, Qhelp_echo
);
7161 help_echo_window
= window
;
7162 help_echo_object
= overlay
;
7163 help_echo_pos
= pos
;
7167 Lisp_Object object
= glyph
->object
;
7168 int charpos
= glyph
->charpos
;
7170 /* Try text properties. */
7171 if (STRINGP (object
)
7173 && charpos
< XSTRING (object
)->size
)
7175 help
= Fget_text_property (make_number (charpos
),
7176 Qhelp_echo
, object
);
7179 /* If the string itself doesn't specify a help-echo,
7180 see if the buffer text ``under'' it does. */
7182 = MATRIX_ROW (w
->current_matrix
, vpos
);
7183 int start
= MATRIX_ROW_START_CHARPOS (r
);
7184 int pos
= string_buffer_position (w
, object
, start
);
7187 help
= Fget_text_property (make_number (pos
),
7188 Qhelp_echo
, w
->buffer
);
7197 else if (BUFFERP (object
)
7200 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
7206 help_echo_window
= window
;
7207 help_echo_object
= object
;
7208 help_echo_pos
= charpos
;
7215 current_buffer
= obuf
;
7221 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7225 redo_mouse_highlight ()
7227 if (!NILP (last_mouse_motion_frame
)
7228 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
7229 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
7230 last_mouse_motion_event
.x
,
7231 last_mouse_motion_event
.y
);
7236 /***********************************************************************
7238 ***********************************************************************/
7240 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
7241 struct glyph
**, int *, int *, int *));
7243 /* Tool-bar item index of the item on which a mouse button was pressed
7246 static int last_tool_bar_item
;
7249 /* Get information about the tool-bar item at position X/Y on frame F.
7250 Return in *GLYPH a pointer to the glyph of the tool-bar item in
7251 the current matrix of the tool-bar window of F, or NULL if not
7252 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
7253 item in F->tool_bar_items. Value is
7255 -1 if X/Y is not on a tool-bar item
7256 0 if X/Y is on the same item that was highlighted before.
7260 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
7263 struct glyph
**glyph
;
7264 int *hpos
, *vpos
, *prop_idx
;
7266 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7267 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7270 /* Find the glyph under X/Y. */
7271 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
, 0);
7275 /* Get the start of this tool-bar item's properties in
7276 f->tool_bar_items. */
7277 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
7280 /* Is mouse on the highlighted item? */
7281 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
7282 && *vpos
>= dpyinfo
->mouse_face_beg_row
7283 && *vpos
<= dpyinfo
->mouse_face_end_row
7284 && (*vpos
> dpyinfo
->mouse_face_beg_row
7285 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
7286 && (*vpos
< dpyinfo
->mouse_face_end_row
7287 || *hpos
< dpyinfo
->mouse_face_end_col
7288 || dpyinfo
->mouse_face_past_end
))
7295 /* Handle mouse button event on the tool-bar of frame F, at
7296 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
7300 x_handle_tool_bar_click (f
, button_event
)
7302 XButtonEvent
*button_event
;
7304 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7305 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7306 int hpos
, vpos
, prop_idx
;
7307 struct glyph
*glyph
;
7308 Lisp_Object enabled_p
;
7309 int x
= button_event
->x
;
7310 int y
= button_event
->y
;
7312 /* If not on the highlighted tool-bar item, return. */
7313 frame_to_window_pixel_xy (w
, &x
, &y
);
7314 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
7317 /* If item is disabled, do nothing. */
7318 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7319 if (NILP (enabled_p
))
7322 if (button_event
->type
== ButtonPress
)
7324 /* Show item in pressed state. */
7325 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
7326 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
7327 last_tool_bar_item
= prop_idx
;
7331 Lisp_Object key
, frame
;
7332 struct input_event event
;
7334 /* Show item in released state. */
7335 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
7336 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
7338 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
7340 XSETFRAME (frame
, f
);
7341 event
.kind
= TOOL_BAR_EVENT
;
7342 event
.frame_or_window
= frame
;
7344 kbd_buffer_store_event (&event
);
7346 event
.kind
= TOOL_BAR_EVENT
;
7347 event
.frame_or_window
= frame
;
7349 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
7350 button_event
->state
);
7351 kbd_buffer_store_event (&event
);
7352 last_tool_bar_item
= -1;
7357 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7358 tool-bar window-relative coordinates X/Y. Called from
7359 note_mouse_highlight. */
7362 note_tool_bar_highlight (f
, x
, y
)
7366 Lisp_Object window
= f
->tool_bar_window
;
7367 struct window
*w
= XWINDOW (window
);
7368 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7370 struct glyph
*glyph
;
7371 struct glyph_row
*row
;
7373 Lisp_Object enabled_p
;
7375 enum draw_glyphs_face draw
;
7376 int mouse_down_p
, rc
;
7378 /* Function note_mouse_highlight is called with negative x(y
7379 values when mouse moves outside of the frame. */
7380 if (x
<= 0 || y
<= 0)
7382 clear_mouse_face (dpyinfo
);
7386 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
7389 /* Not on tool-bar item. */
7390 clear_mouse_face (dpyinfo
);
7396 clear_mouse_face (dpyinfo
);
7398 /* Mouse is down, but on different tool-bar item? */
7399 mouse_down_p
= (dpyinfo
->grabbed
7400 && f
== last_mouse_frame
7401 && FRAME_LIVE_P (f
));
7403 && last_tool_bar_item
!= prop_idx
)
7406 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
7407 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
7409 /* If tool-bar item is not enabled, don't highlight it. */
7410 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7411 if (!NILP (enabled_p
))
7413 /* Compute the x-position of the glyph. In front and past the
7414 image is a space. We include this is the highlighted area. */
7415 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
7416 for (i
= x
= 0; i
< hpos
; ++i
)
7417 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
7419 /* Record this as the current active region. */
7420 dpyinfo
->mouse_face_beg_col
= hpos
;
7421 dpyinfo
->mouse_face_beg_row
= vpos
;
7422 dpyinfo
->mouse_face_beg_x
= x
;
7423 dpyinfo
->mouse_face_beg_y
= row
->y
;
7424 dpyinfo
->mouse_face_past_end
= 0;
7426 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
7427 dpyinfo
->mouse_face_end_row
= vpos
;
7428 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
7429 dpyinfo
->mouse_face_end_y
= row
->y
;
7430 dpyinfo
->mouse_face_window
= window
;
7431 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
7433 /* Display it as active. */
7434 show_mouse_face (dpyinfo
, draw
);
7435 dpyinfo
->mouse_face_image_state
= draw
;
7440 /* Set help_echo to a help string.to display for this tool-bar item.
7441 XTread_socket does the rest. */
7442 help_echo_object
= help_echo_window
= Qnil
;
7444 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
7445 if (NILP (help_echo
))
7446 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
7451 /* Find the glyph matrix position of buffer position POS in window W.
7452 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7453 current glyphs must be up to date. If POS is above window start
7454 return (0, 0, 0, 0). If POS is after end of W, return end of
7458 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
)
7461 int *hpos
, *vpos
, *x
, *y
;
7465 int maybe_next_line_p
= 0;
7466 int line_start_position
;
7467 int yb
= window_text_bottom_y (w
);
7468 struct glyph_row
*row
, *best_row
;
7469 int row_vpos
, best_row_vpos
;
7472 row
= best_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7473 row_vpos
= best_row_vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7477 if (row
->used
[TEXT_AREA
])
7478 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
7480 line_start_position
= 0;
7482 if (line_start_position
> pos
)
7484 /* If the position sought is the end of the buffer,
7485 don't include the blank lines at the bottom of the window. */
7486 else if (line_start_position
== pos
7487 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
7489 maybe_next_line_p
= 1;
7492 else if (line_start_position
> 0)
7495 best_row_vpos
= row_vpos
;
7498 if (row
->y
+ row
->height
>= yb
)
7505 /* Find the right column within BEST_ROW. */
7507 current_x
= best_row
->x
;
7508 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
7510 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
7513 charpos
= glyph
->charpos
;
7517 *vpos
= best_row_vpos
;
7522 else if (charpos
> pos
)
7524 else if (charpos
> 0)
7527 current_x
+= glyph
->pixel_width
;
7530 /* If we're looking for the end of the buffer,
7531 and we didn't find it in the line we scanned,
7532 use the start of the following line. */
7533 if (maybe_next_line_p
)
7538 current_x
= best_row
->x
;
7541 *vpos
= best_row_vpos
;
7542 *hpos
= lastcol
+ 1;
7549 /* Find the position of the the glyph for position POS in OBJECT in
7550 window W's current matrix, and return in *X/*Y the pixel
7551 coordinates, and return in *HPOS/*VPOS the column/row of the glyph.
7553 RIGHT_P non-zero means return the position of the right edge of the
7554 glyph, RIGHT_P zero means return the left edge position.
7556 If no glyph for POS exists in the matrix, return the position of
7557 the glyph with the next smaller position that is in the matrix, if
7558 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
7559 exists in the matrix, return the position of the glyph with the
7560 next larger position in OBJECT.
7562 Value is non-zero if a glyph was found. */
7565 fast_find_string_pos (w
, pos
, object
, hpos
, vpos
, x
, y
, right_p
)
7569 int *hpos
, *vpos
, *x
, *y
;
7572 int yb
= window_text_bottom_y (w
);
7573 struct glyph_row
*r
;
7574 struct glyph
*best_glyph
= NULL
;
7575 struct glyph_row
*best_row
= NULL
;
7578 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7579 r
->enabled_p
&& r
->y
< yb
;
7582 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7583 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
7586 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
7587 if (EQ (g
->object
, object
))
7589 if (g
->charpos
== pos
)
7596 else if (best_glyph
== NULL
7597 || ((abs (g
->charpos
- pos
)
7598 < abs (best_glyph
->charpos
- pos
))
7601 : g
->charpos
> pos
)))
7615 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
7619 *x
+= best_glyph
->pixel_width
;
7624 *vpos
= best_row
- w
->current_matrix
->rows
;
7627 return best_glyph
!= NULL
;
7631 /* Display the active region described by mouse_face_*
7632 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7635 show_mouse_face (dpyinfo
, draw
)
7636 struct x_display_info
*dpyinfo
;
7637 enum draw_glyphs_face draw
;
7639 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
7640 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7642 int cursor_off_p
= 0;
7643 struct cursor_pos saved_cursor
;
7645 saved_cursor
= output_cursor
;
7647 /* If window is in the process of being destroyed, don't bother
7649 if (w
->current_matrix
== NULL
)
7652 /* Recognize when we are called to operate on rows that don't exist
7653 anymore. This can happen when a window is split. */
7654 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
7657 set_output_cursor (&w
->phys_cursor
);
7659 /* Note that mouse_face_beg_row etc. are window relative. */
7660 for (i
= dpyinfo
->mouse_face_beg_row
;
7661 i
<= dpyinfo
->mouse_face_end_row
;
7664 int start_hpos
, end_hpos
, start_x
;
7665 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
7667 /* Don't do anything if row doesn't have valid contents. */
7668 if (!row
->enabled_p
)
7671 /* For all but the first row, the highlight starts at column 0. */
7672 if (i
== dpyinfo
->mouse_face_beg_row
)
7674 start_hpos
= dpyinfo
->mouse_face_beg_col
;
7675 start_x
= dpyinfo
->mouse_face_beg_x
;
7683 if (i
== dpyinfo
->mouse_face_end_row
)
7684 end_hpos
= dpyinfo
->mouse_face_end_col
;
7686 end_hpos
= row
->used
[TEXT_AREA
];
7688 /* If the cursor's in the text we are about to rewrite, turn the
7690 if (!w
->pseudo_window_p
7691 && i
== output_cursor
.vpos
7692 && output_cursor
.hpos
>= start_hpos
- 1
7693 && output_cursor
.hpos
<= end_hpos
)
7695 x_update_window_cursor (w
, 0);
7699 if (end_hpos
> start_hpos
)
7701 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
7702 start_hpos
, end_hpos
, draw
, NULL
, NULL
, 0);
7703 row
->mouse_face_p
= draw
== DRAW_MOUSE_FACE
|| DRAW_IMAGE_RAISED
;
7707 /* If we turned the cursor off, turn it back on. */
7709 x_display_cursor (w
, 1,
7710 output_cursor
.hpos
, output_cursor
.vpos
,
7711 output_cursor
.x
, output_cursor
.y
);
7713 output_cursor
= saved_cursor
;
7717 /* Change the mouse cursor. */
7718 if (draw
== DRAW_NORMAL_TEXT
)
7719 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7720 f
->output_data
.x
->text_cursor
);
7721 else if (draw
== DRAW_MOUSE_FACE
)
7722 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7723 f
->output_data
.x
->cross_cursor
);
7725 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7726 f
->output_data
.x
->nontext_cursor
);
7729 /* Clear out the mouse-highlighted active region.
7730 Redraw it un-highlighted first. Value is non-zero if mouse
7731 face was actually drawn unhighlighted. */
7734 clear_mouse_face (dpyinfo
)
7735 struct x_display_info
*dpyinfo
;
7739 if (!NILP (dpyinfo
->mouse_face_window
))
7741 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7745 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7746 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7747 dpyinfo
->mouse_face_window
= Qnil
;
7748 dpyinfo
->mouse_face_overlay
= Qnil
;
7753 /* Clear any mouse-face on window W. This function is part of the
7754 redisplay interface, and is called from try_window_id and similar
7755 functions to ensure the mouse-highlight is off. */
7758 x_clear_mouse_face (w
)
7761 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
7765 XSETWINDOW (window
, w
);
7766 if (EQ (window
, dpyinfo
->mouse_face_window
))
7767 clear_mouse_face (dpyinfo
);
7772 /* Just discard the mouse face information for frame F, if any.
7773 This is used when the size of F is changed. */
7776 cancel_mouse_face (f
)
7780 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7782 window
= dpyinfo
->mouse_face_window
;
7783 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7785 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7786 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7787 dpyinfo
->mouse_face_window
= Qnil
;
7792 static int glyph_rect
P_ ((struct frame
*f
, int, int, XRectangle
*));
7795 /* Try to determine frame pixel position and size of the glyph under
7796 frame pixel coordinates X/Y on frame F . Return the position and
7797 size in *RECT. Value is non-zero if we could compute these
7801 glyph_rect (f
, x
, y
, rect
)
7807 int part
, found
= 0;
7809 window
= window_from_coordinates (f
, x
, y
, &part
, 0);
7812 struct window
*w
= XWINDOW (window
);
7813 struct glyph_row
*r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7814 struct glyph_row
*end
= r
+ w
->current_matrix
->nrows
- 1;
7817 frame_to_window_pixel_xy (w
, &x
, &y
);
7819 for (; !found
&& r
< end
&& r
->enabled_p
; ++r
)
7822 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7823 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
7826 for (gx
= r
->x
; !found
&& g
< end
; gx
+= g
->pixel_width
, ++g
)
7829 rect
->width
= g
->pixel_width
;
7830 rect
->height
= r
->height
;
7831 rect
->x
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
7832 rect
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
7842 /* Return the current position of the mouse.
7843 *FP should be a frame which indicates which display to ask about.
7845 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
7846 and *PART to the frame, window, and scroll bar part that the mouse
7847 is over. Set *X and *Y to the portion and whole of the mouse's
7848 position on the scroll bar.
7850 If the mouse movement started elsewhere, set *FP to the frame the
7851 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
7854 Set *TIME to the server time-stamp for the time at which the mouse
7855 was at this position.
7857 Don't store anything if we don't have a valid set of values to report.
7859 This clears the mouse_moved flag, so we can wait for the next mouse
7863 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7866 Lisp_Object
*bar_window
;
7867 enum scroll_bar_part
*part
;
7869 unsigned long *time
;
7875 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7876 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7882 Window dummy_window
;
7885 Lisp_Object frame
, tail
;
7887 /* Clear the mouse-moved flag for every frame on this display. */
7888 FOR_EACH_FRAME (tail
, frame
)
7889 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
7890 XFRAME (frame
)->mouse_moved
= 0;
7892 last_mouse_scroll_bar
= Qnil
;
7894 /* Figure out which root window we're on. */
7895 XQueryPointer (FRAME_X_DISPLAY (*fp
),
7896 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
7898 /* The root window which contains the pointer. */
7901 /* Trash which we can't trust if the pointer is on
7902 a different screen. */
7905 /* The position on that root window. */
7908 /* More trash we can't trust. */
7911 /* Modifier keys and pointer buttons, about which
7913 (unsigned int *) &dummy
);
7915 /* Now we have a position on the root; find the innermost window
7916 containing the pointer. */
7920 int parent_x
= 0, parent_y
= 0;
7925 /* XTranslateCoordinates can get errors if the window
7926 structure is changing at the same time this function
7927 is running. So at least we must not crash from them. */
7929 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
7931 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
7932 && FRAME_LIVE_P (last_mouse_frame
))
7934 /* If mouse was grabbed on a frame, give coords for that frame
7935 even if the mouse is now outside it. */
7936 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7938 /* From-window, to-window. */
7939 root
, FRAME_X_WINDOW (last_mouse_frame
),
7941 /* From-position, to-position. */
7942 root_x
, root_y
, &win_x
, &win_y
,
7946 f1
= last_mouse_frame
;
7952 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7954 /* From-window, to-window. */
7957 /* From-position, to-position. */
7958 root_x
, root_y
, &win_x
, &win_y
,
7963 if (child
== None
|| child
== win
)
7971 /* Now we know that:
7972 win is the innermost window containing the pointer
7973 (XTC says it has no child containing the pointer),
7974 win_x and win_y are the pointer's position in it
7975 (XTC did this the last time through), and
7976 parent_x and parent_y are the pointer's position in win's parent.
7977 (They are what win_x and win_y were when win was child.
7978 If win is the root window, it has no parent, and
7979 parent_{x,y} are invalid, but that's okay, because we'll
7980 never use them in that case.) */
7982 /* Is win one of our frames? */
7983 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
7985 #ifdef USE_X_TOOLKIT
7986 /* If we end up with the menu bar window, say it's not
7989 && f1
->output_data
.x
->menubar_widget
7990 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
7992 #endif /* USE_X_TOOLKIT */
7995 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
7998 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
8000 /* If not, is it one of our scroll bars? */
8003 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
8007 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8013 if (f1
== 0 && insist
> 0)
8014 f1
= SELECTED_FRAME ();
8018 /* Ok, we found a frame. Store all the values.
8019 last_mouse_glyph is a rectangle used to reduce the
8020 generation of mouse events. To not miss any motion
8021 events, we must divide the frame into rectangles of the
8022 size of the smallest character that could be displayed
8023 on it, i.e. into the same rectangles that matrices on
8024 the frame are divided into. */
8026 int width
, height
, gx
, gy
;
8029 if (glyph_rect (f1
, win_x
, win_y
, &rect
))
8030 last_mouse_glyph
= rect
;
8033 width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
8034 height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
8038 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
8039 round down even for negative values. */
8044 gx
= (gx
+ width
- 1) / width
* width
;
8045 gy
= (gy
+ height
- 1) / height
* height
;
8047 last_mouse_glyph
.width
= width
;
8048 last_mouse_glyph
.height
= height
;
8049 last_mouse_glyph
.x
= gx
;
8050 last_mouse_glyph
.y
= gy
;
8056 XSETINT (*x
, win_x
);
8057 XSETINT (*y
, win_y
);
8058 *time
= last_mouse_movement_time
;
8067 #ifdef USE_X_TOOLKIT
8069 /* Atimer callback function for TIMER. Called every 0.1s to process
8070 Xt timeouts, if needed. We must avoid calling XtAppPending as
8071 much as possible because that function does an implicit XFlush
8072 that slows us down. */
8075 x_process_timeouts (timer
)
8076 struct atimer
*timer
;
8078 if (toolkit_scroll_bar_interaction
|| popup_activated_flag
)
8081 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
8082 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
8087 #endif /* USE_X_TOOLKIT */
8090 /* Scroll bar support. */
8092 /* Given an X window ID, find the struct scroll_bar which manages it.
8093 This can be called in GC, so we have to make sure to strip off mark
8096 static struct scroll_bar
*
8097 x_window_to_scroll_bar (window_id
)
8102 for (tail
= Vframe_list
;
8103 XGCTYPE (tail
) == Lisp_Cons
;
8106 Lisp_Object frame
, bar
, condemned
;
8108 frame
= XCAR (tail
);
8109 /* All elements of Vframe_list should be frames. */
8110 if (! GC_FRAMEP (frame
))
8113 /* Scan this frame's scroll bar list for a scroll bar with the
8115 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
8116 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
8117 /* This trick allows us to search both the ordinary and
8118 condemned scroll bar lists with one loop. */
8119 ! GC_NILP (bar
) || (bar
= condemned
,
8122 bar
= XSCROLL_BAR (bar
)->next
)
8123 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
8124 return XSCROLL_BAR (bar
);
8131 #if defined USE_X_TOOLKIT && defined USE_LUCID
8133 /* Return the Lucid menu bar WINDOW is part of. Return null
8134 if WINDOW is not part of a menu bar. */
8137 x_window_to_menu_bar (window
)
8142 for (tail
= Vframe_list
;
8143 XGCTYPE (tail
) == Lisp_Cons
;
8146 Lisp_Object frame
= XCAR (tail
);
8147 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
8149 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
8156 #endif /* USE_X_TOOLKIT && USE_LUCID */
8159 /************************************************************************
8161 ************************************************************************/
8163 #ifdef USE_TOOLKIT_SCROLL_BARS
8165 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
8166 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
8167 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
8168 struct scroll_bar
*));
8169 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
8173 /* Id of action hook installed for scroll bars. */
8175 static XtActionHookId action_hook_id
;
8177 /* Lisp window being scrolled. Set when starting to interact with
8178 a toolkit scroll bar, reset to nil when ending the interaction. */
8180 static Lisp_Object window_being_scrolled
;
8182 /* Last scroll bar part sent in xm_scroll_callback. */
8184 static int last_scroll_bar_part
;
8186 /* Whether this is an Xaw with arrow-scrollbars. This should imply
8187 that movements of 1/20 of the screen size are mapped to up/down. */
8189 static Boolean xaw3d_arrow_scroll
;
8191 /* Whether the drag scrolling maintains the mouse at the top of the
8192 thumb. If not, resizing the thumb needs to be done more carefully
8193 to avoid jerkyness. */
8195 static Boolean xaw3d_pick_top
;
8198 /* Action hook installed via XtAppAddActionHook when toolkit scroll
8199 bars are used.. The hook is responsible for detecting when
8200 the user ends an interaction with the scroll bar, and generates
8201 a `end-scroll' scroll_bar_click' event if so. */
8204 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
8207 XtPointer client_data
;
8211 Cardinal
*num_params
;
8217 scroll_bar_p
= XmIsScrollBar (widget
);
8218 end_action
= "Release";
8219 #else /* !USE_MOTIF i.e. use Xaw */
8220 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
8221 end_action
= "EndScroll";
8222 #endif /* USE_MOTIF */
8225 && strcmp (action_name
, end_action
) == 0
8226 && WINDOWP (window_being_scrolled
))
8230 x_send_scroll_bar_event (window_being_scrolled
,
8231 scroll_bar_end_scroll
, 0, 0);
8232 w
= XWINDOW (window_being_scrolled
);
8233 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
8234 window_being_scrolled
= Qnil
;
8235 last_scroll_bar_part
= -1;
8237 /* Xt timeouts no longer needed. */
8238 toolkit_scroll_bar_interaction
= 0;
8242 /* A vector of windows used for communication between
8243 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
8245 static struct window
**scroll_bar_windows
;
8246 static int scroll_bar_windows_size
;
8249 /* Send a client message with message type Xatom_Scrollbar for a
8250 scroll action to the frame of WINDOW. PART is a value identifying
8251 the part of the scroll bar that was clicked on. PORTION is the
8252 amount to scroll of a whole of WHOLE. */
8255 x_send_scroll_bar_event (window
, part
, portion
, whole
)
8257 int part
, portion
, whole
;
8260 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
8261 struct window
*w
= XWINDOW (window
);
8262 struct frame
*f
= XFRAME (w
->frame
);
8267 /* Construct a ClientMessage event to send to the frame. */
8268 ev
->type
= ClientMessage
;
8269 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
8270 ev
->display
= FRAME_X_DISPLAY (f
);
8271 ev
->window
= FRAME_X_WINDOW (f
);
8274 /* We can only transfer 32 bits in the XClientMessageEvent, which is
8275 not enough to store a pointer or Lisp_Object on a 64 bit system.
8276 So, store the window in scroll_bar_windows and pass the index
8277 into that array in the event. */
8278 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
8279 if (scroll_bar_windows
[i
] == NULL
)
8282 if (i
== scroll_bar_windows_size
)
8284 int new_size
= max (10, 2 * scroll_bar_windows_size
);
8285 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
8286 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
8288 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
8290 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
8291 scroll_bar_windows_size
= new_size
;
8294 scroll_bar_windows
[i
] = w
;
8295 ev
->data
.l
[0] = (long) i
;
8296 ev
->data
.l
[1] = (long) part
;
8297 ev
->data
.l
[2] = (long) 0;
8298 ev
->data
.l
[3] = (long) portion
;
8299 ev
->data
.l
[4] = (long) whole
;
8301 /* Make Xt timeouts work while the scroll bar is active. */
8302 toolkit_scroll_bar_interaction
= 1;
8304 /* Setting the event mask to zero means that the message will
8305 be sent to the client that created the window, and if that
8306 window no longer exists, no event will be sent. */
8307 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
8312 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
8316 x_scroll_bar_to_input_event (event
, ievent
)
8318 struct input_event
*ievent
;
8320 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
8325 w
= scroll_bar_windows
[ev
->data
.l
[0]];
8326 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
8328 XSETWINDOW (window
, w
);
8329 f
= XFRAME (w
->frame
);
8331 ievent
->kind
= scroll_bar_click
;
8332 ievent
->frame_or_window
= window
;
8334 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
8335 ievent
->part
= ev
->data
.l
[1];
8336 ievent
->code
= ev
->data
.l
[2];
8337 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
8338 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
8339 ievent
->modifiers
= 0;
8345 /* Minimum and maximum values used for Motif scroll bars. */
8348 #define XM_SB_MAX 10000000
8349 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
8352 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
8353 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
8354 CALL_DATA is a pointer a a XmScrollBarCallbackStruct. */
8357 xm_scroll_callback (widget
, client_data
, call_data
)
8359 XtPointer client_data
, call_data
;
8361 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8362 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
8364 int part
= -1, whole
= 0, portion
= 0;
8368 case XmCR_DECREMENT
:
8369 bar
->dragging
= Qnil
;
8370 part
= scroll_bar_up_arrow
;
8373 case XmCR_INCREMENT
:
8374 bar
->dragging
= Qnil
;
8375 part
= scroll_bar_down_arrow
;
8378 case XmCR_PAGE_DECREMENT
:
8379 bar
->dragging
= Qnil
;
8380 part
= scroll_bar_above_handle
;
8383 case XmCR_PAGE_INCREMENT
:
8384 bar
->dragging
= Qnil
;
8385 part
= scroll_bar_below_handle
;
8389 bar
->dragging
= Qnil
;
8390 part
= scroll_bar_to_top
;
8393 case XmCR_TO_BOTTOM
:
8394 bar
->dragging
= Qnil
;
8395 part
= scroll_bar_to_bottom
;
8401 int dragging_down_p
= (INTEGERP (bar
->dragging
)
8402 && XINT (bar
->dragging
) <= cs
->value
);
8404 /* Get the slider size. */
8406 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
8409 /* At the max position of the scroll bar, do a line-wise
8410 movement. Without doing anything, we would be called with
8411 the same cs->value again and again. If we want to make
8412 sure that we can reach the end of the buffer, we have to do
8415 Implementation note: setting bar->dragging always to
8416 cs->value gives a smoother movement at the max position.
8417 Setting it to nil when doing line-wise movement gives
8418 a better slider behavior. */
8420 if (cs
->value
+ slider_size
== XM_SB_MAX
8422 && last_scroll_bar_part
== scroll_bar_down_arrow
))
8424 part
= scroll_bar_down_arrow
;
8425 bar
->dragging
= Qnil
;
8429 whole
= XM_SB_RANGE
;
8430 portion
= min (cs
->value
- XM_SB_MIN
, XM_SB_MAX
- slider_size
);
8431 part
= scroll_bar_handle
;
8432 bar
->dragging
= make_number (cs
->value
);
8437 case XmCR_VALUE_CHANGED
:
8443 window_being_scrolled
= bar
->window
;
8444 last_scroll_bar_part
= part
;
8445 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
8450 #else /* !USE_MOTIF, i.e. Xaw. */
8453 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
8454 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
8455 scroll bar struct. CALL_DATA is a pointer to a float saying where
8459 xaw_jump_callback (widget
, client_data
, call_data
)
8461 XtPointer client_data
, call_data
;
8463 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8464 float top
= *(float *) call_data
;
8466 int whole
, portion
, height
;
8469 /* Get the size of the thumb, a value between 0 and 1. */
8471 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
8475 portion
= shown
< 1 ? top
* whole
: 0;
8477 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
8478 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
8479 the bottom, so we force the scrolling whenever we see that we're
8480 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
8481 we try to ensure that we always stay two pixels away from the
8483 part
= scroll_bar_down_arrow
;
8485 part
= scroll_bar_handle
;
8487 window_being_scrolled
= bar
->window
;
8488 bar
->dragging
= make_number (portion
);
8489 last_scroll_bar_part
= part
;
8490 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
8494 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
8495 i.e. line or page up or down. WIDGET is the Xaw scroll bar
8496 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
8497 the scroll bar. CALL_DATA is an integer specifying the action that
8498 has taken place. It's magnitude is in the range 0..height of the
8499 scroll bar. Negative values mean scroll towards buffer start.
8500 Values < height of scroll bar mean line-wise movement. */
8503 xaw_scroll_callback (widget
, client_data
, call_data
)
8505 XtPointer client_data
, call_data
;
8507 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8508 int position
= (int) call_data
;
8512 /* Get the height of the scroll bar. */
8514 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
8517 if (abs (position
) >= height
)
8518 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
8520 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
8521 it maps line-movement to call_data = max(5, height/20). */
8522 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
8523 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
8525 part
= scroll_bar_move_ratio
;
8527 window_being_scrolled
= bar
->window
;
8528 bar
->dragging
= Qnil
;
8529 last_scroll_bar_part
= part
;
8530 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
8534 #endif /* not USE_MOTIF */
8537 /* Create the widget for scroll bar BAR on frame F. Record the widget
8538 and X window of the scroll bar in BAR. */
8541 x_create_toolkit_scroll_bar (f
, bar
)
8543 struct scroll_bar
*bar
;
8549 char *scroll_bar_name
= "verticalScrollBar";
8550 unsigned long pixel
;
8555 /* Set resources. Create the widget. */
8556 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8557 XtSetArg (av
[ac
], XmNminimum
, XM_SB_MIN
); ++ac
;
8558 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
8559 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
8560 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
8561 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
8562 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
8564 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8567 XtSetArg (av
[ac
], XmNforeground
, pixel
);
8571 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8574 XtSetArg (av
[ac
], XmNbackground
, pixel
);
8578 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
8579 scroll_bar_name
, av
, ac
);
8581 /* Add one callback for everything that can happen. */
8582 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
8584 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
8586 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
8588 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
8590 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
8592 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
8594 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
8597 /* Realize the widget. Only after that is the X window created. */
8598 XtRealizeWidget (widget
);
8600 /* Set the cursor to an arrow. I didn't find a resource to do that.
8601 And I'm wondering why it hasn't an arrow cursor by default. */
8602 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
8603 f
->output_data
.x
->nontext_cursor
);
8605 #else /* !USE_MOTIF i.e. use Xaw */
8607 /* Set resources. Create the widget. The background of the
8608 Xaw3d scroll bar widget is a little bit light for my taste.
8609 We don't alter it here to let users change it according
8610 to their taste with `emacs*verticalScrollBar.background: xxx'. */
8611 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8612 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
8613 /* For smoother scrolling with Xaw3d -sm */
8614 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
8615 /* XtSetArg (av[ac], XtNbeNiceToColormap, True); ++ac; */
8617 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8620 XtSetArg (av
[ac
], XtNforeground
, pixel
);
8624 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8627 XtSetArg (av
[ac
], XtNbackground
, pixel
);
8631 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
8632 f
->output_data
.x
->edit_widget
, av
, ac
);
8636 char *val
= initial
;
8637 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
8638 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
8640 { /* ARROW_SCROLL */
8641 xaw3d_arrow_scroll
= True
;
8642 /* Isn't that just a personal preference ? -sm */
8643 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
8647 /* Define callbacks. */
8648 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
8649 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
8652 /* Realize the widget. Only after that is the X window created. */
8653 XtRealizeWidget (widget
);
8655 #endif /* !USE_MOTIF */
8657 /* Install an action hook that let's us detect when the user
8658 finishes interacting with a scroll bar. */
8659 if (action_hook_id
== 0)
8660 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
8662 /* Remember X window and widget in the scroll bar vector. */
8663 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
8664 xwindow
= XtWindow (widget
);
8665 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
8671 /* Set the thumb size and position of scroll bar BAR. We are currently
8672 displaying PORTION out of a whole WHOLE, and our position POSITION. */
8675 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
8676 struct scroll_bar
*bar
;
8677 int portion
, position
, whole
;
8679 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8680 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
8687 top
= (float) position
/ whole
;
8688 shown
= (float) portion
/ whole
;
8696 XmScrollBarWidget sb
;
8698 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
8699 is the scroll bar's maximum and MIN is the scroll bar's minimum
8701 size
= shown
* XM_SB_RANGE
;
8702 size
= min (size
, XM_SB_RANGE
);
8703 size
= max (size
, 1);
8705 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
8706 value
= top
* XM_SB_RANGE
;
8707 value
= min (value
, XM_SB_MAX
- size
);
8708 value
= max (value
, XM_SB_MIN
);
8710 if (NILP (bar
->dragging
))
8711 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
8712 else if (last_scroll_bar_part
== scroll_bar_down_arrow
)
8713 /* This has the negative side effect that the slider value is
8714 not what it would be if we scrolled here using line-wise or
8715 page-wise movement. */
8716 XmScrollBarSetValues (widget
, value
, XM_SB_RANGE
- value
, 0, 0, False
);
8719 /* If currently dragging, only update the slider size.
8720 This reduces flicker effects. */
8721 int old_value
, old_size
, increment
, page_increment
;
8723 XmScrollBarGetValues (widget
, &old_value
, &old_size
,
8724 &increment
, &page_increment
);
8725 XmScrollBarSetValues (widget
, old_value
,
8726 min (size
, XM_SB_RANGE
- old_value
),
8730 #else /* !USE_MOTIF i.e. use Xaw */
8732 float old_top
, old_shown
;
8734 XtVaGetValues (widget
,
8735 XtNtopOfThumb
, &old_top
,
8736 XtNshown
, &old_shown
,
8740 /* Massage the top+shown values. */
8741 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
8742 top
= max (0, min (1, top
));
8745 /* Keep two pixels available for moving the thumb down. */
8746 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
8748 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
8749 check that your system's configuration file contains a define
8750 for `NARROWPROTO'. See s/freebsd.h for an example. */
8751 if (top
!= old_top
|| shown
!= old_shown
)
8753 if (NILP (bar
->dragging
))
8754 XawScrollbarSetThumb (widget
, top
, shown
);
8758 ScrollbarWidget sb
= (ScrollbarWidget
) widget
;
8759 int scroll_mode
= 0;
8761 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
8762 if (xaw3d_arrow_scroll
)
8764 /* Xaw3d stupidly ignores resize requests while dragging
8765 so we have to make it believe it's not in dragging mode. */
8766 scroll_mode
= sb
->scrollbar
.scroll_mode
;
8767 if (scroll_mode
== 2)
8768 sb
->scrollbar
.scroll_mode
= 0;
8771 /* Try to make the scrolling a tad smoother. */
8772 if (!xaw3d_pick_top
)
8773 shown
= min (shown
, old_shown
);
8775 XawScrollbarSetThumb (widget
, top
, shown
);
8778 if (xaw3d_arrow_scroll
&& scroll_mode
== 2)
8779 sb
->scrollbar
.scroll_mode
= scroll_mode
;
8784 #endif /* !USE_MOTIF */
8789 #endif /* USE_TOOLKIT_SCROLL_BARS */
8793 /************************************************************************
8794 Scroll bars, general
8795 ************************************************************************/
8797 /* Create a scroll bar and return the scroll bar vector for it. W is
8798 the Emacs window on which to create the scroll bar. TOP, LEFT,
8799 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
8802 static struct scroll_bar
*
8803 x_scroll_bar_create (w
, top
, left
, width
, height
)
8805 int top
, left
, width
, height
;
8807 struct frame
*f
= XFRAME (w
->frame
);
8808 struct scroll_bar
*bar
8809 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
8813 #ifdef USE_TOOLKIT_SCROLL_BARS
8814 x_create_toolkit_scroll_bar (f
, bar
);
8815 #else /* not USE_TOOLKIT_SCROLL_BARS */
8817 XSetWindowAttributes a
;
8821 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8822 if (a
.background_pixel
== -1)
8823 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
8825 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
8826 | ButtonMotionMask
| PointerMotionHintMask
8828 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
8830 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
8832 /* Clear the area of W that will serve as a scroll bar. This is
8833 for the case that a window has been split horizontally. In
8834 this case, no clear_frame is generated to reduce flickering. */
8835 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8837 window_box_height (w
), False
);
8839 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8840 /* Position and size of scroll bar. */
8841 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8843 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8845 /* Border width, depth, class, and visual. */
8852 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
8854 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8856 XSETWINDOW (bar
->window
, w
);
8857 XSETINT (bar
->top
, top
);
8858 XSETINT (bar
->left
, left
);
8859 XSETINT (bar
->width
, width
);
8860 XSETINT (bar
->height
, height
);
8861 XSETINT (bar
->start
, 0);
8862 XSETINT (bar
->end
, 0);
8863 bar
->dragging
= Qnil
;
8865 /* Add bar to its frame's list of scroll bars. */
8866 bar
->next
= FRAME_SCROLL_BARS (f
);
8868 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8869 if (!NILP (bar
->next
))
8870 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8872 /* Map the window/widget. */
8873 #ifdef USE_TOOLKIT_SCROLL_BARS
8875 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
8876 XtConfigureWidget (scroll_bar
,
8877 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8879 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8880 max (height
, 1), 0);
8881 XtMapWidget (scroll_bar
);
8883 #else /* not USE_TOOLKIT_SCROLL_BARS */
8884 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
8885 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8892 /* Draw BAR's handle in the proper position.
8894 If the handle is already drawn from START to END, don't bother
8895 redrawing it, unless REBUILD is non-zero; in that case, always
8896 redraw it. (REBUILD is handy for drawing the handle after expose
8899 Normally, we want to constrain the start and end of the handle to
8900 fit inside its rectangle, but if the user is dragging the scroll
8901 bar handle, we want to let them drag it down all the way, so that
8902 the bar's top is as far down as it goes; otherwise, there's no way
8903 to move to the very end of the buffer. */
8905 #ifndef USE_TOOLKIT_SCROLL_BARS
8908 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
8909 struct scroll_bar
*bar
;
8913 int dragging
= ! NILP (bar
->dragging
);
8914 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8915 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8916 GC gc
= f
->output_data
.x
->normal_gc
;
8918 /* If the display is already accurate, do nothing. */
8920 && start
== XINT (bar
->start
)
8921 && end
== XINT (bar
->end
))
8927 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
8928 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8929 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8931 /* Make sure the values are reasonable, and try to preserve
8932 the distance between start and end. */
8934 int length
= end
- start
;
8938 else if (start
> top_range
)
8940 end
= start
+ length
;
8944 else if (end
> top_range
&& ! dragging
)
8948 /* Store the adjusted setting in the scroll bar. */
8949 XSETINT (bar
->start
, start
);
8950 XSETINT (bar
->end
, end
);
8952 /* Clip the end position, just for display. */
8953 if (end
> top_range
)
8956 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
8957 below top positions, to make sure the handle is always at least
8958 that many pixels tall. */
8959 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8961 /* Draw the empty space above the handle. Note that we can't clear
8962 zero-height areas; that means "clear to end of window." */
8964 x_clear_area (FRAME_X_DISPLAY (f
), w
,
8965 /* x, y, width, height, and exposures. */
8966 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8967 VERTICAL_SCROLL_BAR_TOP_BORDER
,
8968 inside_width
, start
,
8971 /* Change to proper foreground color if one is specified. */
8972 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8973 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8974 f
->output_data
.x
->scroll_bar_foreground_pixel
);
8976 /* Draw the handle itself. */
8977 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8978 /* x, y, width, height */
8979 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8980 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
8981 inside_width
, end
- start
);
8983 /* Restore the foreground color of the GC if we changed it above. */
8984 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8985 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8986 f
->output_data
.x
->foreground_pixel
);
8988 /* Draw the empty space below the handle. Note that we can't
8989 clear zero-height areas; that means "clear to end of window." */
8990 if (end
< inside_height
)
8991 x_clear_area (FRAME_X_DISPLAY (f
), w
,
8992 /* x, y, width, height, and exposures. */
8993 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8994 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
8995 inside_width
, inside_height
- end
,
9003 #endif /* !USE_TOOLKIT_SCROLL_BARS */
9005 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
9009 x_scroll_bar_remove (bar
)
9010 struct scroll_bar
*bar
;
9012 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9015 #ifdef USE_TOOLKIT_SCROLL_BARS
9016 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
9018 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
9021 /* Disassociate this scroll bar from its window. */
9022 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
9028 /* Set the handle of the vertical scroll bar for WINDOW to indicate
9029 that we are displaying PORTION characters out of a total of WHOLE
9030 characters, starting at POSITION. If WINDOW has no scroll bar,
9034 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
9036 int portion
, whole
, position
;
9038 struct frame
*f
= XFRAME (w
->frame
);
9039 struct scroll_bar
*bar
;
9040 int top
, height
, left
, sb_left
, width
, sb_width
;
9041 int window_x
, window_y
, window_width
, window_height
;
9043 /* Get window dimensions. */
9044 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
9046 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
9047 height
= window_height
;
9049 /* Compute the left edge of the scroll bar area. */
9050 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9051 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
9053 left
= XFASTINT (w
->left
);
9054 left
*= CANON_X_UNIT (f
);
9055 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
9057 /* Compute the width of the scroll bar which might be less than
9058 the width of the area reserved for the scroll bar. */
9059 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
9060 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
9064 /* Compute the left edge of the scroll bar. */
9065 #ifdef USE_TOOLKIT_SCROLL_BARS
9066 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9067 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
9069 sb_left
= left
+ (width
- sb_width
) / 2;
9071 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
9072 sb_left
= left
+ width
- sb_width
;
9077 /* Does the scroll bar exist yet? */
9078 if (NILP (w
->vertical_scroll_bar
))
9081 if (width
&& height
)
9082 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9083 left
, top
, width
, height
, False
);
9085 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
9089 /* It may just need to be moved and resized. */
9090 unsigned int mask
= 0;
9092 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
9096 if (sb_left
!= XINT (bar
->left
))
9098 if (top
!= XINT (bar
->top
))
9100 if (sb_width
!= XINT (bar
->width
))
9102 if (height
!= XINT (bar
->height
))
9105 #ifdef USE_TOOLKIT_SCROLL_BARS
9107 /* Since toolkit scroll bars are smaller than the space reserved
9108 for them on the frame, we have to clear "under" them. */
9109 if (width
&& height
)
9110 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9111 left
, top
, width
, height
, False
);
9113 /* Move/size the scroll bar widget. */
9115 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
9116 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9118 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
9119 max (height
, 1), 0);
9121 #else /* not USE_TOOLKIT_SCROLL_BARS */
9123 /* Clear areas not covered by the scroll bar because of
9124 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
9125 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
9127 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9128 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9130 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9131 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9132 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
9136 /* Clear areas not covered by the scroll bar because it's not as
9137 wide as the area reserved for it . This makes sure a
9138 previous mode line display is cleared after C-x 2 C-x 1, for
9141 int area_width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
9142 int rest
= area_width
- sb_width
;
9144 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9145 left
+ area_width
- rest
, 0,
9146 rest
, max (height
, 1), False
);
9149 /* Move/size the scroll bar window. */
9154 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
9156 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
9158 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
9162 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9164 /* Remember new settings. */
9165 XSETINT (bar
->left
, sb_left
);
9166 XSETINT (bar
->top
, top
);
9167 XSETINT (bar
->width
, sb_width
);
9168 XSETINT (bar
->height
, height
);
9173 #ifdef USE_TOOLKIT_SCROLL_BARS
9174 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
9175 #else /* not USE_TOOLKIT_SCROLL_BARS */
9176 /* Set the scroll bar's current state, unless we're currently being
9178 if (NILP (bar
->dragging
))
9180 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
9183 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
9186 int start
= ((double) position
* top_range
) / whole
;
9187 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
9188 x_scroll_bar_set_handle (bar
, start
, end
, 0);
9191 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9193 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
9197 /* The following three hooks are used when we're doing a thorough
9198 redisplay of the frame. We don't explicitly know which scroll bars
9199 are going to be deleted, because keeping track of when windows go
9200 away is a real pain - "Can you say set-window-configuration, boys
9201 and girls?" Instead, we just assert at the beginning of redisplay
9202 that *all* scroll bars are to be removed, and then save a scroll bar
9203 from the fiery pit when we actually redisplay its window. */
9205 /* Arrange for all scroll bars on FRAME to be removed at the next call
9206 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
9207 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
9210 XTcondemn_scroll_bars (frame
)
9213 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
9214 while (! NILP (FRAME_SCROLL_BARS (frame
)))
9217 bar
= FRAME_SCROLL_BARS (frame
);
9218 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
9219 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
9220 XSCROLL_BAR (bar
)->prev
= Qnil
;
9221 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
9222 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
9223 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
9228 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
9229 Note that WINDOW isn't necessarily condemned at all. */
9232 XTredeem_scroll_bar (window
)
9233 struct window
*window
;
9235 struct scroll_bar
*bar
;
9238 /* We can't redeem this window's scroll bar if it doesn't have one. */
9239 if (NILP (window
->vertical_scroll_bar
))
9242 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
9244 /* Unlink it from the condemned list. */
9245 f
= XFRAME (WINDOW_FRAME (window
));
9246 if (NILP (bar
->prev
))
9248 /* If the prev pointer is nil, it must be the first in one of
9250 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
9251 /* It's not condemned. Everything's fine. */
9253 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
9254 window
->vertical_scroll_bar
))
9255 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
9257 /* If its prev pointer is nil, it must be at the front of
9258 one or the other! */
9262 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
9264 if (! NILP (bar
->next
))
9265 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
9267 bar
->next
= FRAME_SCROLL_BARS (f
);
9269 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
9270 if (! NILP (bar
->next
))
9271 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
9274 /* Remove all scroll bars on FRAME that haven't been saved since the
9275 last call to `*condemn_scroll_bars_hook'. */
9278 XTjudge_scroll_bars (f
)
9281 Lisp_Object bar
, next
;
9283 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
9285 /* Clear out the condemned list now so we won't try to process any
9286 more events on the hapless scroll bars. */
9287 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
9289 for (; ! NILP (bar
); bar
= next
)
9291 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
9293 x_scroll_bar_remove (b
);
9296 b
->next
= b
->prev
= Qnil
;
9299 /* Now there should be no references to the condemned scroll bars,
9300 and they should get garbage-collected. */
9304 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
9305 is a no-op when using toolkit scroll bars.
9307 This may be called from a signal handler, so we have to ignore GC
9311 x_scroll_bar_expose (bar
, event
)
9312 struct scroll_bar
*bar
;
9315 #ifndef USE_TOOLKIT_SCROLL_BARS
9317 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9318 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9319 GC gc
= f
->output_data
.x
->normal_gc
;
9320 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
9324 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
9326 /* Draw a one-pixel border just inside the edges of the scroll bar. */
9327 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
9329 /* x, y, width, height */
9331 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
9332 XINT (bar
->height
) - 1);
9336 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9339 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
9340 is set to something other than no_event, it is enqueued.
9342 This may be called from a signal handler, so we have to ignore GC
9345 #ifndef USE_TOOLKIT_SCROLL_BARS
9348 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
9349 struct scroll_bar
*bar
;
9351 struct input_event
*emacs_event
;
9353 if (! GC_WINDOWP (bar
->window
))
9356 emacs_event
->kind
= scroll_bar_click
;
9357 emacs_event
->code
= event
->xbutton
.button
- Button1
;
9358 emacs_event
->modifiers
9359 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
9360 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
9361 event
->xbutton
.state
)
9362 | (event
->type
== ButtonRelease
9365 emacs_event
->frame_or_window
= bar
->window
;
9366 emacs_event
->arg
= Qnil
;
9367 emacs_event
->timestamp
= event
->xbutton
.time
;
9370 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9372 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9375 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9376 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
9379 if (y
> top_range
) y
= top_range
;
9381 if (y
< XINT (bar
->start
))
9382 emacs_event
->part
= scroll_bar_above_handle
;
9383 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
9384 emacs_event
->part
= scroll_bar_handle
;
9386 emacs_event
->part
= scroll_bar_below_handle
;
9388 /* Just because the user has clicked on the handle doesn't mean
9389 they want to drag it. Lisp code needs to be able to decide
9390 whether or not we're dragging. */
9392 /* If the user has just clicked on the handle, record where they're
9394 if (event
->type
== ButtonPress
9395 && emacs_event
->part
== scroll_bar_handle
)
9396 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
9399 /* If the user has released the handle, set it to its final position. */
9400 if (event
->type
== ButtonRelease
9401 && ! NILP (bar
->dragging
))
9403 int new_start
= y
- XINT (bar
->dragging
);
9404 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
9406 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
9407 bar
->dragging
= Qnil
;
9410 /* Same deal here as the other #if 0. */
9412 /* Clicks on the handle are always reported as occurring at the top of
9414 if (emacs_event
->part
== scroll_bar_handle
)
9415 emacs_event
->x
= bar
->start
;
9417 XSETINT (emacs_event
->x
, y
);
9419 XSETINT (emacs_event
->x
, y
);
9422 XSETINT (emacs_event
->y
, top_range
);
9426 /* Handle some mouse motion while someone is dragging the scroll bar.
9428 This may be called from a signal handler, so we have to ignore GC
9432 x_scroll_bar_note_movement (bar
, event
)
9433 struct scroll_bar
*bar
;
9436 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
9438 last_mouse_movement_time
= event
->xmotion
.time
;
9441 XSETVECTOR (last_mouse_scroll_bar
, bar
);
9443 /* If we're dragging the bar, display it. */
9444 if (! GC_NILP (bar
->dragging
))
9446 /* Where should the handle be now? */
9447 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
9449 if (new_start
!= XINT (bar
->start
))
9451 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
9453 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
9458 #endif /* !USE_TOOLKIT_SCROLL_BARS */
9460 /* Return information to the user about the current position of the mouse
9461 on the scroll bar. */
9464 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
9466 Lisp_Object
*bar_window
;
9467 enum scroll_bar_part
*part
;
9469 unsigned long *time
;
9471 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
9472 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9473 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9475 Window dummy_window
;
9477 unsigned int dummy_mask
;
9481 /* Get the mouse's position relative to the scroll bar window, and
9483 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
9485 /* Root, child, root x and root y. */
9486 &dummy_window
, &dummy_window
,
9487 &dummy_coord
, &dummy_coord
,
9489 /* Position relative to scroll bar. */
9492 /* Mouse buttons and modifier keys. */
9499 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9502 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9504 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
9506 if (! NILP (bar
->dragging
))
9507 win_y
-= XINT (bar
->dragging
);
9511 if (win_y
> top_range
)
9515 *bar_window
= bar
->window
;
9517 if (! NILP (bar
->dragging
))
9518 *part
= scroll_bar_handle
;
9519 else if (win_y
< XINT (bar
->start
))
9520 *part
= scroll_bar_above_handle
;
9521 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
9522 *part
= scroll_bar_handle
;
9524 *part
= scroll_bar_below_handle
;
9526 XSETINT (*x
, win_y
);
9527 XSETINT (*y
, top_range
);
9530 last_mouse_scroll_bar
= Qnil
;
9533 *time
= last_mouse_movement_time
;
9539 /* The screen has been cleared so we may have changed foreground or
9540 background colors, and the scroll bars may need to be redrawn.
9541 Clear out the scroll bars, and ask for expose events, so we can
9545 x_scroll_bar_clear (f
)
9548 #ifndef USE_TOOLKIT_SCROLL_BARS
9551 /* We can have scroll bars even if this is 0,
9552 if we just turned off scroll bar mode.
9553 But in that case we should not clear them. */
9554 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
9555 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
9556 bar
= XSCROLL_BAR (bar
)->next
)
9557 XClearArea (FRAME_X_DISPLAY (f
),
9558 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
9560 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9563 /* This processes Expose events from the menu-bar specific X event
9564 loop in xmenu.c. This allows to redisplay the frame if necessary
9565 when handling menu-bar or pop-up items. */
9568 process_expose_from_menu (event
)
9572 struct x_display_info
*dpyinfo
;
9573 int frame_exposed_p
= 0;
9577 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
9578 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
9581 if (f
->async_visible
== 0)
9583 f
->async_visible
= 1;
9584 f
->async_iconified
= 0;
9585 f
->output_data
.x
->has_been_visible
= 1;
9586 SET_FRAME_GARBAGED (f
);
9590 expose_frame (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
9591 event
.xexpose
.x
, event
.xexpose
.y
,
9592 event
.xexpose
.width
, event
.xexpose
.height
);
9593 frame_exposed_p
= 1;
9598 struct scroll_bar
*bar
9599 = x_window_to_scroll_bar (event
.xexpose
.window
);
9602 x_scroll_bar_expose (bar
, &event
);
9606 return frame_exposed_p
;
9609 /* Define a queue to save up SelectionRequest events for later handling. */
9611 struct selection_event_queue
9614 struct selection_event_queue
*next
;
9617 static struct selection_event_queue
*queue
;
9619 /* Nonzero means queue up certain events--don't process them yet. */
9621 static int x_queue_selection_requests
;
9623 /* Queue up an X event *EVENT, to be processed later. */
9626 x_queue_event (f
, event
)
9630 struct selection_event_queue
*queue_tmp
9631 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
9633 if (queue_tmp
!= NULL
)
9635 queue_tmp
->event
= *event
;
9636 queue_tmp
->next
= queue
;
9641 /* Take all the queued events and put them back
9642 so that they get processed afresh. */
9645 x_unqueue_events (display
)
9648 while (queue
!= NULL
)
9650 struct selection_event_queue
*queue_tmp
= queue
;
9651 XPutBackEvent (display
, &queue_tmp
->event
);
9652 queue
= queue_tmp
->next
;
9653 xfree ((char *)queue_tmp
);
9657 /* Start queuing SelectionRequest events. */
9660 x_start_queuing_selection_requests (display
)
9663 x_queue_selection_requests
++;
9666 /* Stop queuing SelectionRequest events. */
9669 x_stop_queuing_selection_requests (display
)
9672 x_queue_selection_requests
--;
9673 x_unqueue_events (display
);
9676 /* The main X event-reading loop - XTread_socket. */
9678 /* Time stamp of enter window event. This is only used by XTread_socket,
9679 but we have to put it out here, since static variables within functions
9680 sometimes don't work. */
9682 static Time enter_timestamp
;
9684 /* This holds the state XLookupString needs to implement dead keys
9685 and other tricks known as "compose processing". _X Window System_
9686 says that a portable program can't use this, but Stephen Gildea assures
9687 me that letting the compiler initialize it to zeros will work okay.
9689 This must be defined outside of XTread_socket, for the same reasons
9690 given for enter_time stamp, above. */
9692 static XComposeStatus compose_status
;
9694 /* Record the last 100 characters stored
9695 to help debug the loss-of-chars-during-GC problem. */
9697 static int temp_index
;
9698 static short temp_buffer
[100];
9700 /* Set this to nonzero to fake an "X I/O error"
9701 on a particular display. */
9703 struct x_display_info
*XTread_socket_fake_io_error
;
9705 /* When we find no input here, we occasionally do a no-op command
9706 to verify that the X server is still running and we can still talk with it.
9707 We try all the open displays, one by one.
9708 This variable is used for cycling thru the displays. */
9710 static struct x_display_info
*next_noop_dpyinfo
;
9712 #define SET_SAVED_MENU_EVENT(size) \
9715 if (f->output_data.x->saved_menu_event == 0) \
9716 f->output_data.x->saved_menu_event \
9717 = (XEvent *) xmalloc (sizeof (XEvent)); \
9718 bcopy (&event, f->output_data.x->saved_menu_event, size); \
9719 if (numchars >= 1) \
9721 bufp->kind = menu_bar_activate_event; \
9722 XSETFRAME (bufp->frame_or_window, f); \
9731 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
9732 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
9734 /* Read events coming from the X server.
9735 This routine is called by the SIGIO handler.
9736 We return as soon as there are no more events to be read.
9738 Events representing keys are stored in buffer BUFP,
9739 which can hold up to NUMCHARS characters.
9740 We return the number of characters stored into the buffer,
9741 thus pretending to be `read'.
9743 EXPECTED is nonzero if the caller knows input is available. */
9746 XTread_socket (sd
, bufp
, numchars
, expected
)
9748 /* register */ struct input_event
*bufp
;
9749 /* register */ int numchars
;
9756 int event_found
= 0;
9757 struct x_display_info
*dpyinfo
;
9758 struct coding_system coding
;
9760 if (interrupt_input_blocked
)
9762 interrupt_input_pending
= 1;
9766 interrupt_input_pending
= 0;
9769 /* So people can tell when we have read the available input. */
9770 input_signal_count
++;
9773 abort (); /* Don't think this happens. */
9777 /* The input should be decoded if it is from XIM. Currently the
9778 locale of XIM is the same as that of the system. So, we can use
9779 Vlocale_coding_system which is initialized properly at Emacs
9781 setup_coding_system (Vlocale_coding_system
, &coding
);
9782 coding
.src_multibyte
= 0;
9783 coding
.dst_multibyte
= 1;
9784 /* The input is converted to events, thus we can't handle
9785 composition. Anyway, there's no XIM that gives us composition
9787 coding
.composing
= COMPOSITION_DISABLED
;
9789 /* Find the display we are supposed to read input for.
9790 It's the one communicating on descriptor SD. */
9791 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
9793 #if 0 /* This ought to be unnecessary; let's verify it. */
9795 /* If available, Xlib uses FIOSNBIO to make the socket
9796 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
9797 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
9798 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
9799 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
9800 #endif /* ! defined (FIOSNBIO) */
9803 #if 0 /* This code can't be made to work, with multiple displays,
9804 and appears not to be used on any system any more.
9805 Also keyboard.c doesn't turn O_NDELAY on and off
9806 for X connections. */
9809 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
9811 extern int read_alarm_should_throw
;
9812 read_alarm_should_throw
= 1;
9813 XPeekEvent (dpyinfo
->display
, &event
);
9814 read_alarm_should_throw
= 0;
9816 #endif /* HAVE_SELECT */
9820 /* For debugging, this gives a way to fake an I/O error. */
9821 if (dpyinfo
== XTread_socket_fake_io_error
)
9823 XTread_socket_fake_io_error
= 0;
9824 x_io_error_quitter (dpyinfo
->display
);
9827 while (XPending (dpyinfo
->display
))
9829 XNextEvent (dpyinfo
->display
, &event
);
9833 /* Filter events for the current X input method.
9834 XFilterEvent returns non-zero if the input method has
9835 consumed the event. We pass the frame's X window to
9836 XFilterEvent because that's the one for which the IC
9838 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
9839 event
.xclient
.window
);
9840 if (XFilterEvent (&event
, f1
? FRAME_X_WINDOW (f1
) : None
))
9850 if (event
.xclient
.message_type
9851 == dpyinfo
->Xatom_wm_protocols
9852 && event
.xclient
.format
== 32)
9854 if (event
.xclient
.data
.l
[0]
9855 == dpyinfo
->Xatom_wm_take_focus
)
9857 /* Use x_any_window_to_frame because this
9858 could be the shell widget window
9859 if the frame has no title bar. */
9860 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
9862 /* Not quite sure this is needed -pd */
9863 if (f
&& FRAME_XIC (f
))
9864 XSetICFocus (FRAME_XIC (f
));
9866 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
9867 instructs the WM to set the input focus automatically for
9868 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
9869 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
9870 it has set the focus. So, XSetInputFocus below is not
9873 The call to XSetInputFocus below has also caused trouble. In
9874 cases where the XSetInputFocus done by the WM and the one
9875 below are temporally close (on a fast machine), the call
9876 below can generate additional FocusIn events which confuse
9879 /* Since we set WM_TAKE_FOCUS, we must call
9880 XSetInputFocus explicitly. But not if f is null,
9881 since that might be an event for a deleted frame. */
9884 Display
*d
= event
.xclient
.display
;
9885 /* Catch and ignore errors, in case window has been
9886 iconified by a window manager such as GWM. */
9887 int count
= x_catch_errors (d
);
9888 XSetInputFocus (d
, event
.xclient
.window
,
9889 /* The ICCCM says this is
9890 the only valid choice. */
9892 event
.xclient
.data
.l
[1]);
9893 /* This is needed to detect the error
9894 if there is an error. */
9896 x_uncatch_errors (d
, count
);
9898 /* Not certain about handling scroll bars here */
9901 else if (event
.xclient
.data
.l
[0]
9902 == dpyinfo
->Xatom_wm_save_yourself
)
9904 /* Save state modify the WM_COMMAND property to
9905 something which can reinstate us. This notifies
9906 the session manager, who's looking for such a
9907 PropertyNotify. Can restart processing when
9908 a keyboard or mouse event arrives. */
9911 f
= x_top_window_to_frame (dpyinfo
,
9912 event
.xclient
.window
);
9914 /* This is just so we only give real data once
9915 for a single Emacs process. */
9916 if (f
== SELECTED_FRAME ())
9917 XSetCommand (FRAME_X_DISPLAY (f
),
9918 event
.xclient
.window
,
9919 initial_argv
, initial_argc
);
9921 XSetCommand (FRAME_X_DISPLAY (f
),
9922 event
.xclient
.window
,
9926 else if (event
.xclient
.data
.l
[0]
9927 == dpyinfo
->Xatom_wm_delete_window
)
9930 = x_any_window_to_frame (dpyinfo
,
9931 event
.xclient
.window
);
9938 bufp
->kind
= delete_window_event
;
9939 XSETFRAME (bufp
->frame_or_window
, f
);
9948 else if (event
.xclient
.message_type
9949 == dpyinfo
->Xatom_wm_configure_denied
)
9952 else if (event
.xclient
.message_type
9953 == dpyinfo
->Xatom_wm_window_moved
)
9957 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9959 new_x
= event
.xclient
.data
.s
[0];
9960 new_y
= event
.xclient
.data
.s
[1];
9964 f
->output_data
.x
->left_pos
= new_x
;
9965 f
->output_data
.x
->top_pos
= new_y
;
9969 else if (event
.xclient
.message_type
9970 == dpyinfo
->Xatom_editres
)
9973 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
9974 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
9977 #endif /* HACK_EDITRES */
9978 else if ((event
.xclient
.message_type
9979 == dpyinfo
->Xatom_DONE
)
9980 || (event
.xclient
.message_type
9981 == dpyinfo
->Xatom_PAGE
))
9983 /* Ghostview job completed. Kill it. We could
9984 reply with "Next" if we received "Page", but we
9985 currently never do because we are interested in
9986 images, only, which should have 1 page. */
9987 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
9989 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9990 x_kill_gs_process (pixmap
, f
);
9991 expose_frame (f
, 0, 0, 0, 0);
9993 #ifdef USE_TOOLKIT_SCROLL_BARS
9994 /* Scroll bar callbacks send a ClientMessage from which
9995 we construct an input_event. */
9996 else if (event
.xclient
.message_type
9997 == dpyinfo
->Xatom_Scrollbar
)
9999 x_scroll_bar_to_input_event (&event
, bufp
);
10000 ++bufp
, ++count
, --numchars
;
10003 #endif /* USE_TOOLKIT_SCROLL_BARS */
10009 case SelectionNotify
:
10010 #ifdef USE_X_TOOLKIT
10011 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
10013 #endif /* not USE_X_TOOLKIT */
10014 x_handle_selection_notify (&event
.xselection
);
10017 case SelectionClear
: /* Someone has grabbed ownership. */
10018 #ifdef USE_X_TOOLKIT
10019 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
10021 #endif /* USE_X_TOOLKIT */
10023 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
10028 bufp
->kind
= selection_clear_event
;
10029 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
10030 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
10031 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
10032 bufp
->frame_or_window
= Qnil
;
10041 case SelectionRequest
: /* Someone wants our selection. */
10042 #ifdef USE_X_TOOLKIT
10043 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
10045 #endif /* USE_X_TOOLKIT */
10046 if (x_queue_selection_requests
)
10047 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
10051 XSelectionRequestEvent
*eventp
10052 = (XSelectionRequestEvent
*) &event
;
10057 bufp
->kind
= selection_request_event
;
10058 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
10059 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
10060 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
10061 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
10062 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
10063 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
10064 bufp
->frame_or_window
= Qnil
;
10073 case PropertyNotify
:
10074 #if 0 /* This is plain wrong. In the case that we are waiting for a
10075 PropertyNotify used as an ACK in incremental selection
10076 transfer, the property will be on the receiver's window. */
10077 #if defined USE_X_TOOLKIT
10078 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
10082 x_handle_property_notify (&event
.xproperty
);
10085 case ReparentNotify
:
10086 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
10090 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
10091 x_real_positions (f
, &x
, &y
);
10092 f
->output_data
.x
->left_pos
= x
;
10093 f
->output_data
.x
->top_pos
= y
;
10098 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
10101 if (f
->async_visible
== 0)
10103 f
->async_visible
= 1;
10104 f
->async_iconified
= 0;
10105 f
->output_data
.x
->has_been_visible
= 1;
10106 SET_FRAME_GARBAGED (f
);
10109 expose_frame (x_window_to_frame (dpyinfo
,
10110 event
.xexpose
.window
),
10111 event
.xexpose
.x
, event
.xexpose
.y
,
10112 event
.xexpose
.width
, event
.xexpose
.height
);
10116 #ifndef USE_TOOLKIT_SCROLL_BARS
10117 struct scroll_bar
*bar
;
10119 #if defined USE_X_TOOLKIT && defined USE_LUCID
10120 /* Submenus of the Lucid menu bar aren't widgets
10121 themselves, so there's no way to dispatch events
10122 to them. Recognize this case separately. */
10125 = x_window_to_menu_bar (event
.xexpose
.window
);
10127 xlwmenu_redisplay (widget
);
10129 #endif /* USE_X_TOOLKIT && USE_LUCID */
10131 #ifdef USE_TOOLKIT_SCROLL_BARS
10132 /* Dispatch event to the widget. */
10134 #else /* not USE_TOOLKIT_SCROLL_BARS */
10135 bar
= x_window_to_scroll_bar (event
.xexpose
.window
);
10138 x_scroll_bar_expose (bar
, &event
);
10139 #ifdef USE_X_TOOLKIT
10142 #endif /* USE_X_TOOLKIT */
10143 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10147 case GraphicsExpose
: /* This occurs when an XCopyArea's
10148 source area was obscured or not
10150 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
10154 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
10155 event
.xgraphicsexpose
.width
,
10156 event
.xgraphicsexpose
.height
);
10158 #ifdef USE_X_TOOLKIT
10161 #endif /* USE_X_TOOLKIT */
10164 case NoExpose
: /* This occurs when an XCopyArea's
10165 source area was completely
10170 /* Redo the mouse-highlight after the tooltip has gone. */
10171 if (event
.xmap
.window
== tip_window
)
10174 redo_mouse_highlight ();
10177 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
10178 if (f
) /* F may no longer exist if
10179 the frame was deleted. */
10181 /* While a frame is unmapped, display generation is
10182 disabled; you don't want to spend time updating a
10183 display that won't ever be seen. */
10184 f
->async_visible
= 0;
10185 /* We can't distinguish, from the event, whether the window
10186 has become iconified or invisible. So assume, if it
10187 was previously visible, than now it is iconified.
10188 But x_make_frame_invisible clears both
10189 the visible flag and the iconified flag;
10190 and that way, we know the window is not iconified now. */
10191 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
10193 f
->async_iconified
= 1;
10195 bufp
->kind
= iconify_event
;
10196 XSETFRAME (bufp
->frame_or_window
, f
);
10206 if (event
.xmap
.window
== tip_window
)
10207 /* The tooltip has been drawn already. Avoid
10208 the SET_FRAME_GARBAGED below. */
10211 /* We use x_top_window_to_frame because map events can
10212 come for sub-windows and they don't mean that the
10213 frame is visible. */
10214 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
10217 f
->async_visible
= 1;
10218 f
->async_iconified
= 0;
10219 f
->output_data
.x
->has_been_visible
= 1;
10221 /* wait_reading_process_input will notice this and update
10222 the frame's display structures. */
10223 SET_FRAME_GARBAGED (f
);
10227 bufp
->kind
= deiconify_event
;
10228 XSETFRAME (bufp
->frame_or_window
, f
);
10234 else if (! NILP (Vframe_list
)
10235 && ! NILP (XCDR (Vframe_list
)))
10236 /* Force a redisplay sooner or later
10237 to update the frame titles
10238 in case this is the second frame. */
10239 record_asynch_buffer_change ();
10244 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
10246 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
10249 /* Scroll bars consume key events, but we want
10250 the keys to go to the scroll bar's frame. */
10251 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
10252 event
.xkey
.window
);
10253 if (widget
&& XmIsScrollBar (widget
))
10255 widget
= XtParent (widget
);
10256 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
10259 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
10263 KeySym keysym
, orig_keysym
;
10264 /* al%imercury@uunet.uu.net says that making this 81
10265 instead of 80 fixed a bug whereby meta chars made
10268 It seems that some version of XmbLookupString has
10269 a bug of not returning XBufferOverflow in
10270 status_return even if the input is too long to
10271 fit in 81 bytes. So, we must prepare sufficient
10272 bytes for copy_buffer. 513 bytes (256 chars for
10273 two-byte character set) seems to be a faily good
10274 approximation. -- 2000.8.10 handa@etl.go.jp */
10275 unsigned char copy_buffer
[513];
10276 unsigned char *copy_bufptr
= copy_buffer
;
10277 int copy_bufsiz
= sizeof (copy_buffer
);
10281 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
10282 extra_keyboard_modifiers
);
10283 modifiers
= event
.xkey
.state
;
10285 /* This will have to go some day... */
10287 /* make_lispy_event turns chars into control chars.
10288 Don't do it here because XLookupString is too eager. */
10289 event
.xkey
.state
&= ~ControlMask
;
10290 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
10291 | dpyinfo
->super_mod_mask
10292 | dpyinfo
->hyper_mod_mask
10293 | dpyinfo
->alt_mod_mask
);
10295 /* In case Meta is ComposeCharacter,
10296 clear its status. According to Markus Ehrnsperger
10297 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
10298 this enables ComposeCharacter to work whether or
10299 not it is combined with Meta. */
10300 if (modifiers
& dpyinfo
->meta_mod_mask
)
10301 bzero (&compose_status
, sizeof (compose_status
));
10306 Status status_return
;
10308 nbytes
= XmbLookupString (FRAME_XIC (f
),
10309 &event
.xkey
, copy_bufptr
,
10310 copy_bufsiz
, &keysym
,
10312 if (status_return
== XBufferOverflow
)
10314 copy_bufsiz
= nbytes
+ 1;
10315 copy_bufptr
= (char *) alloca (copy_bufsiz
);
10316 nbytes
= XmbLookupString (FRAME_XIC (f
),
10317 &event
.xkey
, copy_bufptr
,
10318 copy_bufsiz
, &keysym
,
10322 if (status_return
== XLookupNone
)
10324 else if (status_return
== XLookupChars
)
10329 else if (status_return
!= XLookupKeySym
10330 && status_return
!= XLookupBoth
)
10334 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
10335 copy_bufsiz
, &keysym
,
10338 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
10339 copy_bufsiz
, &keysym
,
10343 orig_keysym
= keysym
;
10347 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
10348 || keysym
== XK_Delete
10349 #ifdef XK_ISO_Left_Tab
10350 || (keysym
>= XK_ISO_Left_Tab
&& keysym
<= XK_ISO_Enter
)
10352 || (keysym
>= XK_Kanji
&& keysym
<= XK_Eisu_toggle
)
10353 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
10354 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
10356 /* This recognizes the "extended function keys".
10357 It seems there's no cleaner way.
10358 Test IsModifierKey to avoid handling mode_switch
10360 || ((unsigned) (keysym
) >= XK_Select
10361 && (unsigned)(keysym
) < XK_KP_Space
)
10363 #ifdef XK_dead_circumflex
10364 || orig_keysym
== XK_dead_circumflex
10366 #ifdef XK_dead_grave
10367 || orig_keysym
== XK_dead_grave
10369 #ifdef XK_dead_tilde
10370 || orig_keysym
== XK_dead_tilde
10372 #ifdef XK_dead_diaeresis
10373 || orig_keysym
== XK_dead_diaeresis
10375 #ifdef XK_dead_macron
10376 || orig_keysym
== XK_dead_macron
10378 #ifdef XK_dead_degree
10379 || orig_keysym
== XK_dead_degree
10381 #ifdef XK_dead_acute
10382 || orig_keysym
== XK_dead_acute
10384 #ifdef XK_dead_cedilla
10385 || orig_keysym
== XK_dead_cedilla
10387 #ifdef XK_dead_breve
10388 || orig_keysym
== XK_dead_breve
10390 #ifdef XK_dead_ogonek
10391 || orig_keysym
== XK_dead_ogonek
10393 #ifdef XK_dead_caron
10394 || orig_keysym
== XK_dead_caron
10396 #ifdef XK_dead_doubleacute
10397 || orig_keysym
== XK_dead_doubleacute
10399 #ifdef XK_dead_abovedot
10400 || orig_keysym
== XK_dead_abovedot
10402 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
10403 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
10404 /* Any "vendor-specific" key is ok. */
10405 || (orig_keysym
& (1 << 28)))
10406 && ! (IsModifierKey (orig_keysym
)
10408 #ifdef XK_Mode_switch
10409 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
10412 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
10414 #endif /* not HAVE_X11R5 */
10417 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
10419 temp_buffer
[temp_index
++] = keysym
;
10420 bufp
->kind
= non_ascii_keystroke
;
10421 bufp
->code
= keysym
;
10422 XSETFRAME (bufp
->frame_or_window
, f
);
10425 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
10427 bufp
->timestamp
= event
.xkey
.time
;
10432 else if (numchars
> nbytes
)
10438 for (i
= 0; i
< nbytes
; i
++)
10440 if (temp_index
== (sizeof temp_buffer
10443 temp_buffer
[temp_index
++] = copy_bufptr
[i
];
10446 if (/* If the event is not from XIM, */
10447 event
.xkey
.keycode
!= 0
10448 /* or the current locale doesn't request
10449 decoding of the intup data, ... */
10450 || coding
.type
== coding_type_raw_text
10451 || coding
.type
== coding_type_no_conversion
)
10453 /* ... we can use the input data as is. */
10458 /* We have to decode the input data. */
10462 require
= decoding_buffer_size (&coding
, nbytes
);
10463 p
= (unsigned char *) alloca (require
);
10464 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
10465 decode_coding (&coding
, copy_bufptr
, p
,
10467 nbytes
= coding
.produced
;
10468 nchars
= coding
.produced_char
;
10472 /* Convert the input data to a sequence of
10473 character events. */
10474 for (i
= 0; i
< nbytes
; i
+= len
)
10476 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
10478 bufp
->kind
= (SINGLE_BYTE_CHAR_P (c
)
10480 : multibyte_char_keystroke
);
10482 XSETFRAME (bufp
->frame_or_window
, f
);
10485 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
10487 bufp
->timestamp
= event
.xkey
.time
;
10492 numchars
-= nchars
;
10494 if (keysym
== NoSymbol
)
10504 /* Don't dispatch this event since XtDispatchEvent calls
10505 XFilterEvent, and two calls in a row may freeze the
10514 /* Don't dispatch this event since XtDispatchEvent calls
10515 XFilterEvent, and two calls in a row may freeze the
10522 /* Here's a possible interpretation of the whole
10523 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If
10524 you get a FocusIn event, you have to get a FocusOut
10525 event before you relinquish the focus. If you
10526 haven't received a FocusIn event, then a mere
10527 LeaveNotify is enough to free you. */
10531 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10533 if (event
.xcrossing
.focus
)
10535 /* Avoid nasty pop/raise loops. */
10536 if (f
&& (!(f
->auto_raise
)
10537 || !(f
->auto_lower
)
10538 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
10540 x_new_focus_frame (dpyinfo
, f
);
10541 enter_timestamp
= event
.xcrossing
.time
;
10544 else if (f
== dpyinfo
->x_focus_frame
)
10545 x_new_focus_frame (dpyinfo
, 0);
10547 /* EnterNotify counts as mouse movement,
10548 so update things that depend on mouse position. */
10549 if (f
&& !f
->output_data
.x
->hourglass_p
)
10550 note_mouse_movement (f
, &event
.xmotion
);
10555 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
10556 if (event
.xfocus
.detail
!= NotifyPointer
)
10557 dpyinfo
->x_focus_event_frame
= f
;
10560 x_new_focus_frame (dpyinfo
, f
);
10562 /* Don't stop displaying the initial startup message
10563 for a switch-frame event we don't need. */
10564 if (GC_NILP (Vterminal_frame
)
10565 && GC_CONSP (Vframe_list
)
10566 && !GC_NILP (XCDR (Vframe_list
)))
10568 bufp
->kind
= FOCUS_IN_EVENT
;
10569 XSETFRAME (bufp
->frame_or_window
, f
);
10571 ++bufp
, ++count
, --numchars
;
10576 if (f
&& FRAME_XIC (f
))
10577 XSetICFocus (FRAME_XIC (f
));
10583 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10586 if (f
== dpyinfo
->mouse_face_mouse_frame
)
10588 /* If we move outside the frame, then we're
10589 certainly no longer on any text in the frame. */
10590 clear_mouse_face (dpyinfo
);
10591 dpyinfo
->mouse_face_mouse_frame
= 0;
10594 /* Generate a nil HELP_EVENT to cancel a help-echo.
10595 Do it only if there's something to cancel.
10596 Otherwise, the startup message is cleared when
10597 the mouse leaves the frame. */
10598 if (any_help_event_p
)
10603 XSETFRAME (frame
, f
);
10605 n
= gen_help_event (bufp
, numchars
,
10606 Qnil
, frame
, Qnil
, Qnil
, 0);
10607 bufp
+= n
, count
+= n
, numchars
-= n
;
10610 if (event
.xcrossing
.focus
)
10611 x_mouse_leave (dpyinfo
);
10614 if (f
== dpyinfo
->x_focus_event_frame
)
10615 dpyinfo
->x_focus_event_frame
= 0;
10616 if (f
== dpyinfo
->x_focus_frame
)
10617 x_new_focus_frame (dpyinfo
, 0);
10623 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
10624 if (event
.xfocus
.detail
!= NotifyPointer
10625 && f
== dpyinfo
->x_focus_event_frame
)
10626 dpyinfo
->x_focus_event_frame
= 0;
10627 if (f
&& f
== dpyinfo
->x_focus_frame
)
10628 x_new_focus_frame (dpyinfo
, 0);
10631 if (f
&& FRAME_XIC (f
))
10632 XUnsetICFocus (FRAME_XIC (f
));
10639 previous_help_echo
= help_echo
;
10640 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
10641 help_echo_pos
= -1;
10643 if (dpyinfo
->grabbed
&& last_mouse_frame
10644 && FRAME_LIVE_P (last_mouse_frame
))
10645 f
= last_mouse_frame
;
10647 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
10650 note_mouse_movement (f
, &event
.xmotion
);
10653 #ifndef USE_TOOLKIT_SCROLL_BARS
10654 struct scroll_bar
*bar
10655 = x_window_to_scroll_bar (event
.xmotion
.window
);
10658 x_scroll_bar_note_movement (bar
, &event
);
10659 #endif /* USE_TOOLKIT_SCROLL_BARS */
10661 /* If we move outside the frame, then we're
10662 certainly no longer on any text in the frame. */
10663 clear_mouse_face (dpyinfo
);
10666 /* If the contents of the global variable help_echo
10667 has changed, generate a HELP_EVENT. */
10668 if (!NILP (help_echo
)
10669 || !NILP (previous_help_echo
))
10675 XSETFRAME (frame
, f
);
10679 any_help_event_p
= 1;
10680 n
= gen_help_event (bufp
, numchars
, help_echo
, frame
,
10681 help_echo_window
, help_echo_object
,
10683 bufp
+= n
, count
+= n
, numchars
-= n
;
10689 case ConfigureNotify
:
10690 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
10693 #ifndef USE_X_TOOLKIT
10694 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
10695 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
10697 /* In the toolkit version, change_frame_size
10698 is called by the code that handles resizing
10699 of the EmacsFrame widget. */
10701 /* Even if the number of character rows and columns has
10702 not changed, the font size may have changed, so we need
10703 to check the pixel dimensions as well. */
10704 if (columns
!= f
->width
10705 || rows
!= f
->height
10706 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
10707 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
10709 change_frame_size (f
, rows
, columns
, 0, 1, 0);
10710 SET_FRAME_GARBAGED (f
);
10711 cancel_mouse_face (f
);
10715 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
10716 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
10718 /* What we have now is the position of Emacs's own window.
10719 Convert that to the position of the window manager window. */
10720 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
10721 &f
->output_data
.x
->top_pos
);
10724 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
10725 xic_set_statusarea (f
);
10728 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
10730 /* Since the WM decorations come below top_pos now,
10731 we must put them below top_pos in the future. */
10732 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
10733 x_wm_set_size_hint (f
, (long) 0, 0);
10736 /* Some window managers pass (0,0) as the location of
10737 the window, and the Motif event handler stores it
10738 in the emacs widget, which messes up Motif menus. */
10739 if (event
.xconfigure
.x
== 0 && event
.xconfigure
.y
== 0)
10741 event
.xconfigure
.x
= f
->output_data
.x
->widget
->core
.x
;
10742 event
.xconfigure
.y
= f
->output_data
.x
->widget
->core
.y
;
10744 #endif /* USE_MOTIF */
10749 case ButtonRelease
:
10751 /* If we decide we want to generate an event to be seen
10752 by the rest of Emacs, we put it here. */
10753 struct input_event emacs_event
;
10754 int tool_bar_p
= 0;
10756 emacs_event
.kind
= no_event
;
10757 bzero (&compose_status
, sizeof (compose_status
));
10759 if (dpyinfo
->grabbed
10760 && last_mouse_frame
10761 && FRAME_LIVE_P (last_mouse_frame
))
10762 f
= last_mouse_frame
;
10764 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
10768 /* Is this in the tool-bar? */
10769 if (WINDOWP (f
->tool_bar_window
)
10770 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
10772 Lisp_Object window
;
10775 x
= event
.xbutton
.x
;
10776 y
= event
.xbutton
.y
;
10779 window
= window_from_coordinates (f
, x
, y
, &p
, 1);
10780 if (EQ (window
, f
->tool_bar_window
))
10782 x_handle_tool_bar_click (f
, &event
.xbutton
);
10788 if (!dpyinfo
->x_focus_frame
10789 || f
== dpyinfo
->x_focus_frame
)
10790 construct_mouse_click (&emacs_event
, &event
, f
);
10794 #ifndef USE_TOOLKIT_SCROLL_BARS
10795 struct scroll_bar
*bar
10796 = x_window_to_scroll_bar (event
.xbutton
.window
);
10799 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
10800 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10803 if (event
.type
== ButtonPress
)
10805 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
10806 last_mouse_frame
= f
;
10807 /* Ignore any mouse motion that happened
10808 before this event; any subsequent mouse-movement
10809 Emacs events should reflect only motion after
10810 the ButtonPress. */
10812 f
->mouse_moved
= 0;
10815 last_tool_bar_item
= -1;
10819 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
10822 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
10824 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
10830 #ifdef USE_X_TOOLKIT
10831 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
10832 /* For a down-event in the menu bar,
10833 don't pass it to Xt right now.
10834 Instead, save it away
10835 and we will pass it to Xt from kbd_buffer_get_event.
10836 That way, we can run some Lisp code first. */
10837 if (f
&& event
.type
== ButtonPress
10838 /* Verify the event is really within the menu bar
10839 and not just sent to it due to grabbing. */
10840 && event
.xbutton
.x
>= 0
10841 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
10842 && event
.xbutton
.y
>= 0
10843 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
10844 && event
.xbutton
.same_screen
)
10846 SET_SAVED_BUTTON_EVENT
;
10847 XSETFRAME (last_mouse_press_frame
, f
);
10849 else if (event
.type
== ButtonPress
)
10851 last_mouse_press_frame
= Qnil
;
10855 #ifdef USE_MOTIF /* This should do not harm for Lucid,
10856 but I am trying to be cautious. */
10857 else if (event
.type
== ButtonRelease
)
10859 if (!NILP (last_mouse_press_frame
))
10861 f
= XFRAME (last_mouse_press_frame
);
10862 if (f
->output_data
.x
)
10863 SET_SAVED_BUTTON_EVENT
;
10868 #endif /* USE_MOTIF */
10871 #endif /* USE_X_TOOLKIT */
10875 case CirculateNotify
:
10878 case CirculateRequest
:
10881 case VisibilityNotify
:
10884 case MappingNotify
:
10885 /* Someone has changed the keyboard mapping - update the
10887 switch (event
.xmapping
.request
)
10889 case MappingModifier
:
10890 x_find_modifier_meanings (dpyinfo
);
10891 /* This is meant to fall through. */
10892 case MappingKeyboard
:
10893 XRefreshKeyboardMapping (&event
.xmapping
);
10899 #ifdef USE_X_TOOLKIT
10901 XtDispatchEvent (&event
);
10903 #endif /* USE_X_TOOLKIT */
10911 /* On some systems, an X bug causes Emacs to get no more events
10912 when the window is destroyed. Detect that. (1994.) */
10915 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
10916 One XNOOP in 100 loops will make Emacs terminate.
10917 B. Bretthauer, 1994 */
10919 if (x_noop_count
>= 100)
10923 if (next_noop_dpyinfo
== 0)
10924 next_noop_dpyinfo
= x_display_list
;
10926 XNoOp (next_noop_dpyinfo
->display
);
10928 /* Each time we get here, cycle through the displays now open. */
10929 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
10933 /* If the focus was just given to an auto-raising frame,
10935 /* ??? This ought to be able to handle more than one such frame. */
10936 if (pending_autoraise_frame
)
10938 x_raise_frame (pending_autoraise_frame
);
10939 pending_autoraise_frame
= 0;
10950 /***********************************************************************
10952 ***********************************************************************/
10954 /* Note if the text cursor of window W has been overwritten by a
10955 drawing operation that outputs N glyphs starting at HPOS in the
10956 line given by output_cursor.vpos. N < 0 means all the rest of the
10957 line after HPOS has been written. */
10960 note_overwritten_text_cursor (w
, hpos
, n
)
10964 if (updated_area
== TEXT_AREA
10965 && output_cursor
.vpos
== w
->phys_cursor
.vpos
10966 && hpos
<= w
->phys_cursor
.hpos
10968 || hpos
+ n
> w
->phys_cursor
.hpos
))
10969 w
->phys_cursor_on_p
= 0;
10973 /* Set clipping for output in glyph row ROW. W is the window in which
10974 we operate. GC is the graphics context to set clipping in.
10975 WHOLE_LINE_P non-zero means include the areas used for truncation
10976 mark display and alike in the clipping rectangle.
10978 ROW may be a text row or, e.g., a mode line. Text rows must be
10979 clipped to the interior of the window dedicated to text display,
10980 mode lines must be clipped to the whole window. */
10983 x_clip_to_row (w
, row
, gc
, whole_line_p
)
10985 struct glyph_row
*row
;
10989 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10990 XRectangle clip_rect
;
10991 int window_x
, window_y
, window_width
, window_height
;
10993 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
10995 clip_rect
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
10996 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
10997 clip_rect
.y
= max (clip_rect
.y
, window_y
);
10998 clip_rect
.width
= window_width
;
10999 clip_rect
.height
= row
->visible_height
;
11001 /* If clipping to the whole line, including trunc marks, extend
11002 the rectangle to the left and increase its width. */
11005 clip_rect
.x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
11006 clip_rect
.width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
11009 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
11013 /* Draw a hollow box cursor on window W in glyph row ROW. */
11016 x_draw_hollow_cursor (w
, row
)
11018 struct glyph_row
*row
;
11020 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
11021 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11022 Display
*dpy
= FRAME_X_DISPLAY (f
);
11025 struct glyph
*cursor_glyph
;
11028 /* Compute frame-relative coordinates from window-relative
11030 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
11031 y
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
11032 + row
->ascent
- w
->phys_cursor_ascent
);
11033 h
= row
->height
- 1;
11035 /* Get the glyph the cursor is on. If we can't tell because
11036 the current matrix is invalid or such, give up. */
11037 cursor_glyph
= get_phys_cursor_glyph (w
);
11038 if (cursor_glyph
== NULL
)
11041 /* Compute the width of the rectangle to draw. If on a stretch
11042 glyph, and `x-stretch-block-cursor' is nil, don't draw a
11043 rectangle as wide as the glyph, but use a canonical character
11045 wd
= cursor_glyph
->pixel_width
- 1;
11046 if (cursor_glyph
->type
== STRETCH_GLYPH
11047 && !x_stretch_cursor_p
)
11048 wd
= min (CANON_X_UNIT (f
), wd
);
11050 /* The foreground of cursor_gc is typically the same as the normal
11051 background color, which can cause the cursor box to be invisible. */
11052 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
11053 if (dpyinfo
->scratch_cursor_gc
)
11054 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
11056 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
11057 GCForeground
, &xgcv
);
11058 gc
= dpyinfo
->scratch_cursor_gc
;
11060 /* Set clipping, draw the rectangle, and reset clipping again. */
11061 x_clip_to_row (w
, row
, gc
, 0);
11062 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
11063 XSetClipMask (dpy
, gc
, None
);
11067 /* Draw a bar cursor on window W in glyph row ROW.
11069 Implementation note: One would like to draw a bar cursor with an
11070 angle equal to the one given by the font property XA_ITALIC_ANGLE.
11071 Unfortunately, I didn't find a font yet that has this property set.
11075 x_draw_bar_cursor (w
, row
, width
)
11077 struct glyph_row
*row
;
11080 struct frame
*f
= XFRAME (w
->frame
);
11081 struct glyph
*cursor_glyph
;
11084 unsigned long mask
;
11089 /* If cursor is out of bounds, don't draw garbage. This can happen
11090 in mini-buffer windows when switching between echo area glyphs
11091 and mini-buffer. */
11092 cursor_glyph
= get_phys_cursor_glyph (w
);
11093 if (cursor_glyph
== NULL
)
11096 /* If on an image, draw like a normal cursor. That's usually better
11097 visible than drawing a bar, esp. if the image is large so that
11098 the bar might not be in the window. */
11099 if (cursor_glyph
->type
== IMAGE_GLYPH
)
11101 struct glyph_row
*row
;
11102 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
11103 x_draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
11107 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
11108 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
11109 xgcv
.graphics_exposures
= 0;
11110 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
11111 dpy
= FRAME_X_DISPLAY (f
);
11112 window
= FRAME_X_WINDOW (f
);
11113 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
11116 XChangeGC (dpy
, gc
, mask
, &xgcv
);
11119 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
11120 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
11124 width
= f
->output_data
.x
->cursor_width
;
11126 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
11127 x_clip_to_row (w
, row
, gc
, 0);
11128 XFillRectangle (dpy
, window
, gc
,
11130 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
11131 min (cursor_glyph
->pixel_width
, width
),
11133 XSetClipMask (dpy
, gc
, None
);
11138 /* Clear the cursor of window W to background color, and mark the
11139 cursor as not shown. This is used when the text where the cursor
11140 is is about to be rewritten. */
11146 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
11147 x_update_window_cursor (w
, 0);
11151 /* Draw the cursor glyph of window W in glyph row ROW. See the
11152 comment of x_draw_glyphs for the meaning of HL. */
11155 x_draw_phys_cursor_glyph (w
, row
, hl
)
11157 struct glyph_row
*row
;
11158 enum draw_glyphs_face hl
;
11160 /* If cursor hpos is out of bounds, don't draw garbage. This can
11161 happen in mini-buffer windows when switching between echo area
11162 glyphs and mini-buffer. */
11163 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
11165 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
11166 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
11169 /* When we erase the cursor, and ROW is overlapped by other
11170 rows, make sure that these overlapping parts of other rows
11172 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
11174 if (row
> w
->current_matrix
->rows
11175 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
11176 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
11178 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
11179 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
11180 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
11186 /* Erase the image of a cursor of window W from the screen. */
11189 x_erase_phys_cursor (w
)
11192 struct frame
*f
= XFRAME (w
->frame
);
11193 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11194 int hpos
= w
->phys_cursor
.hpos
;
11195 int vpos
= w
->phys_cursor
.vpos
;
11196 int mouse_face_here_p
= 0;
11197 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
11198 struct glyph_row
*cursor_row
;
11199 struct glyph
*cursor_glyph
;
11200 enum draw_glyphs_face hl
;
11202 /* No cursor displayed or row invalidated => nothing to do on the
11204 if (w
->phys_cursor_type
== NO_CURSOR
)
11205 goto mark_cursor_off
;
11207 /* VPOS >= active_glyphs->nrows means that window has been resized.
11208 Don't bother to erase the cursor. */
11209 if (vpos
>= active_glyphs
->nrows
)
11210 goto mark_cursor_off
;
11212 /* If row containing cursor is marked invalid, there is nothing we
11214 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
11215 if (!cursor_row
->enabled_p
)
11216 goto mark_cursor_off
;
11218 /* This can happen when the new row is shorter than the old one.
11219 In this case, either x_draw_glyphs or clear_end_of_line
11220 should have cleared the cursor. Note that we wouldn't be
11221 able to erase the cursor in this case because we don't have a
11222 cursor glyph at hand. */
11223 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
11224 goto mark_cursor_off
;
11226 /* If the cursor is in the mouse face area, redisplay that when
11227 we clear the cursor. */
11228 if (! NILP (dpyinfo
->mouse_face_window
)
11229 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
11230 && (vpos
> dpyinfo
->mouse_face_beg_row
11231 || (vpos
== dpyinfo
->mouse_face_beg_row
11232 && hpos
>= dpyinfo
->mouse_face_beg_col
))
11233 && (vpos
< dpyinfo
->mouse_face_end_row
11234 || (vpos
== dpyinfo
->mouse_face_end_row
11235 && hpos
< dpyinfo
->mouse_face_end_col
))
11236 /* Don't redraw the cursor's spot in mouse face if it is at the
11237 end of a line (on a newline). The cursor appears there, but
11238 mouse highlighting does not. */
11239 && cursor_row
->used
[TEXT_AREA
] > hpos
)
11240 mouse_face_here_p
= 1;
11242 /* Maybe clear the display under the cursor. */
11243 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
11246 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
11248 cursor_glyph
= get_phys_cursor_glyph (w
);
11249 if (cursor_glyph
== NULL
)
11250 goto mark_cursor_off
;
11252 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
11254 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11256 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
11258 cursor_glyph
->pixel_width
,
11259 cursor_row
->visible_height
,
11263 /* Erase the cursor by redrawing the character underneath it. */
11264 if (mouse_face_here_p
)
11265 hl
= DRAW_MOUSE_FACE
;
11266 else if (cursor_row
->inverse_p
)
11267 hl
= DRAW_INVERSE_VIDEO
;
11269 hl
= DRAW_NORMAL_TEXT
;
11270 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
11273 w
->phys_cursor_on_p
= 0;
11274 w
->phys_cursor_type
= NO_CURSOR
;
11278 /* Non-zero if physical cursor of window W is within mouse face. */
11281 cursor_in_mouse_face_p (w
)
11284 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
11285 int in_mouse_face
= 0;
11287 if (WINDOWP (dpyinfo
->mouse_face_window
)
11288 && XWINDOW (dpyinfo
->mouse_face_window
) == w
)
11290 int hpos
= w
->phys_cursor
.hpos
;
11291 int vpos
= w
->phys_cursor
.vpos
;
11293 if (vpos
>= dpyinfo
->mouse_face_beg_row
11294 && vpos
<= dpyinfo
->mouse_face_end_row
11295 && (vpos
> dpyinfo
->mouse_face_beg_row
11296 || hpos
>= dpyinfo
->mouse_face_beg_col
)
11297 && (vpos
< dpyinfo
->mouse_face_end_row
11298 || hpos
< dpyinfo
->mouse_face_end_col
11299 || dpyinfo
->mouse_face_past_end
))
11303 return in_mouse_face
;
11307 /* Display or clear cursor of window W. If ON is zero, clear the
11308 cursor. If it is non-zero, display the cursor. If ON is nonzero,
11309 where to put the cursor is specified by HPOS, VPOS, X and Y. */
11312 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
11314 int on
, hpos
, vpos
, x
, y
;
11316 struct frame
*f
= XFRAME (w
->frame
);
11317 int new_cursor_type
;
11318 int new_cursor_width
;
11319 struct glyph_matrix
*current_glyphs
;
11320 struct glyph_row
*glyph_row
;
11321 struct glyph
*glyph
;
11323 /* This is pointless on invisible frames, and dangerous on garbaged
11324 windows and frames; in the latter case, the frame or window may
11325 be in the midst of changing its size, and x and y may be off the
11327 if (! FRAME_VISIBLE_P (f
)
11328 || FRAME_GARBAGED_P (f
)
11329 || vpos
>= w
->current_matrix
->nrows
11330 || hpos
>= w
->current_matrix
->matrix_w
)
11333 /* If cursor is off and we want it off, return quickly. */
11334 if (!on
&& !w
->phys_cursor_on_p
)
11337 current_glyphs
= w
->current_matrix
;
11338 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
11339 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
11341 /* If cursor row is not enabled, we don't really know where to
11342 display the cursor. */
11343 if (!glyph_row
->enabled_p
)
11345 w
->phys_cursor_on_p
= 0;
11349 xassert (interrupt_input_blocked
);
11351 /* Set new_cursor_type to the cursor we want to be displayed. In a
11352 mini-buffer window, we want the cursor only to appear if we are
11353 reading input from this window. For the selected window, we want
11354 the cursor type given by the frame parameter. If explicitly
11355 marked off, draw no cursor. In all other cases, we want a hollow
11357 new_cursor_width
= -1;
11358 if (cursor_in_echo_area
11359 && FRAME_HAS_MINIBUF_P (f
)
11360 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
11362 if (w
== XWINDOW (echo_area_window
))
11363 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
11365 new_cursor_type
= HOLLOW_BOX_CURSOR
;
11369 if (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
11370 || w
!= XWINDOW (f
->selected_window
))
11372 extern int cursor_in_non_selected_windows
;
11374 if (MINI_WINDOW_P (w
)
11375 || !cursor_in_non_selected_windows
11376 || NILP (XBUFFER (w
->buffer
)->cursor_type
))
11377 new_cursor_type
= NO_CURSOR
;
11379 new_cursor_type
= HOLLOW_BOX_CURSOR
;
11381 else if (w
->cursor_off_p
)
11382 new_cursor_type
= NO_CURSOR
;
11385 struct buffer
*b
= XBUFFER (w
->buffer
);
11387 if (EQ (b
->cursor_type
, Qt
))
11388 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
11390 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
11391 &new_cursor_width
);
11395 /* If cursor is currently being shown and we don't want it to be or
11396 it is in the wrong place, or the cursor type is not what we want,
11398 if (w
->phys_cursor_on_p
11400 || w
->phys_cursor
.x
!= x
11401 || w
->phys_cursor
.y
!= y
11402 || new_cursor_type
!= w
->phys_cursor_type
))
11403 x_erase_phys_cursor (w
);
11405 /* If the cursor is now invisible and we want it to be visible,
11407 if (on
&& !w
->phys_cursor_on_p
)
11409 w
->phys_cursor_ascent
= glyph_row
->ascent
;
11410 w
->phys_cursor_height
= glyph_row
->height
;
11412 /* Set phys_cursor_.* before x_draw_.* is called because some
11413 of them may need the information. */
11414 w
->phys_cursor
.x
= x
;
11415 w
->phys_cursor
.y
= glyph_row
->y
;
11416 w
->phys_cursor
.hpos
= hpos
;
11417 w
->phys_cursor
.vpos
= vpos
;
11418 w
->phys_cursor_type
= new_cursor_type
;
11419 w
->phys_cursor_on_p
= 1;
11421 switch (new_cursor_type
)
11423 case HOLLOW_BOX_CURSOR
:
11424 x_draw_hollow_cursor (w
, glyph_row
);
11427 case FILLED_BOX_CURSOR
:
11428 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
11432 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
);
11443 if (w
== XWINDOW (f
->selected_window
))
11444 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
11445 xic_set_preeditarea (w
, x
, y
);
11450 if (updating_frame
!= f
)
11451 XFlush (FRAME_X_DISPLAY (f
));
11456 /* Display the cursor on window W, or clear it. X and Y are window
11457 relative pixel coordinates. HPOS and VPOS are glyph matrix
11458 positions. If W is not the selected window, display a hollow
11459 cursor. ON non-zero means display the cursor at X, Y which
11460 correspond to HPOS, VPOS, otherwise it is cleared. */
11463 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
11465 int on
, hpos
, vpos
, x
, y
;
11468 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
11473 /* Display the cursor on window W, or clear it, according to ON_P.
11474 Don't change the cursor's position. */
11477 x_update_cursor (f
, on_p
)
11480 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
11484 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
11485 in the window tree rooted at W. */
11488 x_update_cursor_in_window_tree (w
, on_p
)
11494 if (!NILP (w
->hchild
))
11495 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
11496 else if (!NILP (w
->vchild
))
11497 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
11499 x_update_window_cursor (w
, on_p
);
11501 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
11506 /* Switch the display of W's cursor on or off, according to the value
11510 x_update_window_cursor (w
, on
)
11514 /* Don't update cursor in windows whose frame is in the process
11515 of being deleted. */
11516 if (w
->current_matrix
)
11519 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
11520 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
11530 /* Refresh bitmap kitchen sink icon for frame F
11531 when we get an expose event for it. */
11537 /* Normally, the window manager handles this function. */
11540 /* Make the x-window of frame F use the gnu icon bitmap. */
11543 x_bitmap_icon (f
, file
)
11549 if (FRAME_X_WINDOW (f
) == 0)
11552 /* Free up our existing icon bitmap if any. */
11553 if (f
->output_data
.x
->icon_bitmap
> 0)
11554 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
11555 f
->output_data
.x
->icon_bitmap
= 0;
11557 if (STRINGP (file
))
11558 bitmap_id
= x_create_bitmap_from_file (f
, file
);
11561 /* Create the GNU bitmap if necessary. */
11562 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
11563 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
11564 = x_create_bitmap_from_data (f
, gnu_bits
,
11565 gnu_width
, gnu_height
);
11567 /* The first time we create the GNU bitmap,
11568 this increments the ref-count one extra time.
11569 As a result, the GNU bitmap is never freed.
11570 That way, we don't have to worry about allocating it again. */
11571 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
11573 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
11576 x_wm_set_icon_pixmap (f
, bitmap_id
);
11577 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
11583 /* Make the x-window of frame F use a rectangle with text.
11584 Use ICON_NAME as the text. */
11587 x_text_icon (f
, icon_name
)
11591 if (FRAME_X_WINDOW (f
) == 0)
11596 XTextProperty text
;
11597 text
.value
= (unsigned char *) icon_name
;
11598 text
.encoding
= XA_STRING
;
11600 text
.nitems
= strlen (icon_name
);
11601 #ifdef USE_X_TOOLKIT
11602 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
11604 #else /* not USE_X_TOOLKIT */
11605 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
11606 #endif /* not USE_X_TOOLKIT */
11608 #else /* not HAVE_X11R4 */
11609 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
11610 #endif /* not HAVE_X11R4 */
11612 if (f
->output_data
.x
->icon_bitmap
> 0)
11613 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
11614 f
->output_data
.x
->icon_bitmap
= 0;
11615 x_wm_set_icon_pixmap (f
, 0);
11620 #define X_ERROR_MESSAGE_SIZE 200
11622 /* If non-nil, this should be a string.
11623 It means catch X errors and store the error message in this string. */
11625 static Lisp_Object x_error_message_string
;
11627 /* An X error handler which stores the error message in
11628 x_error_message_string. This is called from x_error_handler if
11629 x_catch_errors is in effect. */
11632 x_error_catcher (display
, error
)
11634 XErrorEvent
*error
;
11636 XGetErrorText (display
, error
->error_code
,
11637 XSTRING (x_error_message_string
)->data
,
11638 X_ERROR_MESSAGE_SIZE
);
11641 /* Begin trapping X errors for display DPY. Actually we trap X errors
11642 for all displays, but DPY should be the display you are actually
11645 After calling this function, X protocol errors no longer cause
11646 Emacs to exit; instead, they are recorded in the string
11647 stored in x_error_message_string.
11649 Calling x_check_errors signals an Emacs error if an X error has
11650 occurred since the last call to x_catch_errors or x_check_errors.
11652 Calling x_uncatch_errors resumes the normal error handling. */
11654 void x_check_errors ();
11655 static Lisp_Object
x_catch_errors_unwind ();
11658 x_catch_errors (dpy
)
11661 int count
= specpdl_ptr
- specpdl
;
11663 /* Make sure any errors from previous requests have been dealt with. */
11664 XSync (dpy
, False
);
11666 record_unwind_protect (x_catch_errors_unwind
, x_error_message_string
);
11668 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
11669 XSTRING (x_error_message_string
)->data
[0] = 0;
11674 /* Unbind the binding that we made to check for X errors. */
11677 x_catch_errors_unwind (old_val
)
11678 Lisp_Object old_val
;
11680 x_error_message_string
= old_val
;
11684 /* If any X protocol errors have arrived since the last call to
11685 x_catch_errors or x_check_errors, signal an Emacs error using
11686 sprintf (a buffer, FORMAT, the x error message text) as the text. */
11689 x_check_errors (dpy
, format
)
11693 /* Make sure to catch any errors incurred so far. */
11694 XSync (dpy
, False
);
11696 if (XSTRING (x_error_message_string
)->data
[0])
11697 error (format
, XSTRING (x_error_message_string
)->data
);
11700 /* Nonzero if we had any X protocol errors
11701 since we did x_catch_errors on DPY. */
11704 x_had_errors_p (dpy
)
11707 /* Make sure to catch any errors incurred so far. */
11708 XSync (dpy
, False
);
11710 return XSTRING (x_error_message_string
)->data
[0] != 0;
11713 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
11716 x_clear_errors (dpy
)
11719 XSTRING (x_error_message_string
)->data
[0] = 0;
11722 /* Stop catching X protocol errors and let them make Emacs die.
11723 DPY should be the display that was passed to x_catch_errors.
11724 COUNT should be the value that was returned by
11725 the corresponding call to x_catch_errors. */
11728 x_uncatch_errors (dpy
, count
)
11732 unbind_to (count
, Qnil
);
11736 static unsigned int x_wire_count
;
11739 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
11744 /* Handle SIGPIPE, which can happen when the connection to a server
11745 simply goes away. SIGPIPE is handled by x_connection_signal.
11746 Don't need to do anything, because the write which caused the
11747 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
11748 which will do the appropriate cleanup for us. */
11751 x_connection_signal (signalnum
) /* If we don't have an argument, */
11752 int signalnum
; /* some compilers complain in signal calls. */
11755 /* USG systems forget handlers when they are used;
11756 must reestablish each time */
11757 signal (signalnum
, x_connection_signal
);
11762 /************************************************************************
11764 ************************************************************************/
11766 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
11767 the text of an error message that lead to the connection loss. */
11770 x_connection_closed (dpy
, error_message
)
11772 char *error_message
;
11774 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
11775 Lisp_Object frame
, tail
;
11779 msg
= (char *) alloca (strlen (error_message
) + 1);
11780 strcpy (msg
, error_message
);
11781 handling_signal
= 0;
11783 /* Prevent being called recursively because of an error condition
11784 below. Otherwise, we might end up with printing ``can't find per
11785 display information'' in the recursive call instead of printing
11786 the original message here. */
11787 count
= x_catch_errors (dpy
);
11789 /* We have to close the display to inform Xt that it doesn't
11790 exist anymore. If we don't, Xt will continue to wait for
11791 events from the display. As a consequence, a sequence of
11793 M-x make-frame-on-display RET :1 RET
11794 ...kill the new frame, so that we get an IO error...
11795 M-x make-frame-on-display RET :1 RET
11797 will indefinitely wait in Xt for events for display `:1', opened
11798 in the first class to make-frame-on-display.
11800 Closing the display is reported to lead to a bus error on
11801 OpenWindows in certain situations. I suspect that is a bug
11802 in OpenWindows. I don't know how to cicumvent it here. */
11804 #ifdef USE_X_TOOLKIT
11805 /* If DPYINFO is null, this means we didn't open the display
11806 in the first place, so don't try to close it. */
11808 XtCloseDisplay (dpy
);
11811 /* Indicate that this display is dead. */
11813 dpyinfo
->display
= 0;
11815 /* First delete frames whose mini-buffers are on frames
11816 that are on the dead display. */
11817 FOR_EACH_FRAME (tail
, frame
)
11819 Lisp_Object minibuf_frame
;
11821 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
11822 if (FRAME_X_P (XFRAME (frame
))
11823 && FRAME_X_P (XFRAME (minibuf_frame
))
11824 && ! EQ (frame
, minibuf_frame
)
11825 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
11826 Fdelete_frame (frame
, Qt
);
11829 /* Now delete all remaining frames on the dead display.
11830 We are now sure none of these is used as the mini-buffer
11831 for another frame that we need to delete. */
11832 FOR_EACH_FRAME (tail
, frame
)
11833 if (FRAME_X_P (XFRAME (frame
))
11834 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
11836 /* Set this to t so that Fdelete_frame won't get confused
11837 trying to find a replacement. */
11838 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
11839 Fdelete_frame (frame
, Qt
);
11843 x_delete_display (dpyinfo
);
11845 x_uncatch_errors (dpy
, count
);
11847 if (x_display_list
== 0)
11849 fprintf (stderr
, "%s\n", msg
);
11850 shut_down_emacs (0, 0, Qnil
);
11854 /* Ordinary stack unwind doesn't deal with these. */
11856 sigunblock (sigmask (SIGIO
));
11858 sigunblock (sigmask (SIGALRM
));
11859 TOTALLY_UNBLOCK_INPUT
;
11861 clear_waiting_for_input ();
11866 /* This is the usual handler for X protocol errors.
11867 It kills all frames on the display that we got the error for.
11868 If that was the only one, it prints an error message and kills Emacs. */
11871 x_error_quitter (display
, error
)
11873 XErrorEvent
*error
;
11875 char buf
[256], buf1
[356];
11877 /* Note that there is no real way portable across R3/R4 to get the
11878 original error handler. */
11880 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
11881 sprintf (buf1
, "X protocol error: %s on protocol request %d",
11882 buf
, error
->request_code
);
11883 x_connection_closed (display
, buf1
);
11887 /* This is the first-level handler for X protocol errors.
11888 It calls x_error_quitter or x_error_catcher. */
11891 x_error_handler (display
, error
)
11893 XErrorEvent
*error
;
11895 if (! NILP (x_error_message_string
))
11896 x_error_catcher (display
, error
);
11898 x_error_quitter (display
, error
);
11902 /* This is the handler for X IO errors, always.
11903 It kills all frames on the display that we lost touch with.
11904 If that was the only one, it prints an error message and kills Emacs. */
11907 x_io_error_quitter (display
)
11912 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
11913 x_connection_closed (display
, buf
);
11917 /* Changing the font of the frame. */
11919 /* Give frame F the font named FONTNAME as its default font, and
11920 return the full name of that font. FONTNAME may be a wildcard
11921 pattern; in that case, we choose some font that fits the pattern.
11922 The return value shows which font we chose. */
11925 x_new_font (f
, fontname
)
11927 register char *fontname
;
11929 struct font_info
*fontp
11930 = FS_LOAD_FONT (f
, 0, fontname
, -1);
11935 f
->output_data
.x
->font
= (XFontStruct
*) (fontp
->font
);
11936 f
->output_data
.x
->baseline_offset
= fontp
->baseline_offset
;
11937 f
->output_data
.x
->fontset
= -1;
11939 /* Compute the scroll bar width in character columns. */
11940 if (f
->scroll_bar_pixel_width
> 0)
11942 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
11943 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
11947 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
11948 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
11951 /* Now make the frame display the given font. */
11952 if (FRAME_X_WINDOW (f
) != 0)
11954 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
11955 f
->output_data
.x
->font
->fid
);
11956 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
11957 f
->output_data
.x
->font
->fid
);
11958 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
11959 f
->output_data
.x
->font
->fid
);
11961 frame_update_line_height (f
);
11963 /* Don't change the size of a tip frame; there's no point in
11964 doing it because it's done in Fx_show_tip, and it leads to
11965 problems because the tip frame has no widget. */
11966 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
11967 x_set_window_size (f
, 0, f
->width
, f
->height
);
11970 /* If we are setting a new frame's font for the first time,
11971 there are no faces yet, so this font's height is the line height. */
11972 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
11974 return build_string (fontp
->full_name
);
11977 /* Give frame F the fontset named FONTSETNAME as its default font, and
11978 return the full name of that fontset. FONTSETNAME may be a wildcard
11979 pattern; in that case, we choose some fontset that fits the pattern.
11980 The return value shows which fontset we chose. */
11983 x_new_fontset (f
, fontsetname
)
11987 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
11988 Lisp_Object result
;
11993 if (f
->output_data
.x
->fontset
== fontset
)
11994 /* This fontset is already set in frame F. There's nothing more
11996 return fontset_name (fontset
);
11998 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
12000 if (!STRINGP (result
))
12001 /* Can't load ASCII font. */
12004 /* Since x_new_font doesn't update any fontset information, do it now. */
12005 f
->output_data
.x
->fontset
= fontset
;
12009 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
12010 xic_set_xfontset (f
, XSTRING (fontset_ascii (fontset
))->data
);
12013 return build_string (fontsetname
);
12017 /***********************************************************************
12019 ***********************************************************************/
12025 /* XIM destroy callback function, which is called whenever the
12026 connection to input method XIM dies. CLIENT_DATA contains a
12027 pointer to the x_display_info structure corresponding to XIM. */
12030 xim_destroy_callback (xim
, client_data
, call_data
)
12032 XPointer client_data
;
12033 XPointer call_data
;
12035 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
12036 Lisp_Object frame
, tail
;
12040 /* No need to call XDestroyIC.. */
12041 FOR_EACH_FRAME (tail
, frame
)
12043 struct frame
*f
= XFRAME (frame
);
12044 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
12046 FRAME_XIC (f
) = NULL
;
12047 if (FRAME_XIC_FONTSET (f
))
12049 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
12050 FRAME_XIC_FONTSET (f
) = NULL
;
12055 /* No need to call XCloseIM. */
12056 dpyinfo
->xim
= NULL
;
12057 XFree (dpyinfo
->xim_styles
);
12061 #endif /* HAVE_X11R6 */
12063 /* Open the connection to the XIM server on display DPYINFO.
12064 RESOURCE_NAME is the resource name Emacs uses. */
12067 xim_open_dpy (dpyinfo
, resource_name
)
12068 struct x_display_info
*dpyinfo
;
12069 char *resource_name
;
12074 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
, EMACS_CLASS
);
12075 dpyinfo
->xim
= xim
;
12080 XIMCallback destroy
;
12083 /* Get supported styles and XIM values. */
12084 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
12087 destroy
.callback
= xim_destroy_callback
;
12088 destroy
.client_data
= (XPointer
)dpyinfo
;
12089 /* This isn't prototyped in OSF 5.0. */
12090 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
12094 #else /* not USE_XIM */
12095 dpyinfo
->xim
= NULL
;
12096 #endif /* not USE_XIM */
12100 #ifdef HAVE_X11R6_XIM
12104 struct x_display_info
*dpyinfo
;
12105 char *resource_name
;
12108 /* XIM instantiate callback function, which is called whenever an XIM
12109 server is available. DISPLAY is teh display of the XIM.
12110 CLIENT_DATA contains a pointer to an xim_inst_t structure created
12111 when the callback was registered. */
12114 xim_instantiate_callback (display
, client_data
, call_data
)
12116 XPointer client_data
;
12117 XPointer call_data
;
12119 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
12120 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
12122 /* We don't support multiple XIM connections. */
12126 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
12128 /* Create XIC for the existing frames on the same display, as long
12129 as they have no XIC. */
12130 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
12132 Lisp_Object tail
, frame
;
12135 FOR_EACH_FRAME (tail
, frame
)
12137 struct frame
*f
= XFRAME (frame
);
12139 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
12140 if (FRAME_XIC (f
) == NULL
)
12142 create_frame_xic (f
);
12143 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
12144 xic_set_statusarea (f
);
12145 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
12147 struct window
*w
= XWINDOW (f
->selected_window
);
12148 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
12157 #endif /* HAVE_X11R6_XIM */
12160 /* Open a connection to the XIM server on display DPYINFO.
12161 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
12162 connection only at the first time. On X11R6, open the connection
12163 in the XIM instantiate callback function. */
12166 xim_initialize (dpyinfo
, resource_name
)
12167 struct x_display_info
*dpyinfo
;
12168 char *resource_name
;
12171 #ifdef HAVE_X11R6_XIM
12172 struct xim_inst_t
*xim_inst
;
12175 dpyinfo
->xim
= NULL
;
12176 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
12177 xim_inst
->dpyinfo
= dpyinfo
;
12178 len
= strlen (resource_name
);
12179 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
12180 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
12181 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
12182 resource_name
, EMACS_CLASS
,
12183 xim_instantiate_callback
,
12184 /* Fixme: This is XPointer in
12185 XFree86 but (XPointer *) on
12186 Tru64, at least. */
12187 (XPointer
) xim_inst
);
12188 #else /* not HAVE_X11R6_XIM */
12189 dpyinfo
->xim
= NULL
;
12190 xim_open_dpy (dpyinfo
, resource_name
);
12191 #endif /* not HAVE_X11R6_XIM */
12193 #else /* not USE_XIM */
12194 dpyinfo
->xim
= NULL
;
12195 #endif /* not USE_XIM */
12199 /* Close the connection to the XIM server on display DPYINFO. */
12202 xim_close_dpy (dpyinfo
)
12203 struct x_display_info
*dpyinfo
;
12206 #ifdef HAVE_X11R6_XIM
12207 if (dpyinfo
->display
)
12208 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
12210 xim_instantiate_callback
, NULL
);
12211 #endif /* not HAVE_X11R6_XIM */
12212 if (dpyinfo
->display
)
12213 XCloseIM (dpyinfo
->xim
);
12214 dpyinfo
->xim
= NULL
;
12215 XFree (dpyinfo
->xim_styles
);
12216 #endif /* USE_XIM */
12219 #endif /* not HAVE_X11R6_XIM */
12223 /* Calculate the absolute position in frame F
12224 from its current recorded position values and gravity. */
12227 x_calc_absolute_position (f
)
12231 int win_x
= 0, win_y
= 0;
12232 int flags
= f
->output_data
.x
->size_hint_flags
;
12235 /* We have nothing to do if the current position
12236 is already for the top-left corner. */
12237 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
12240 #ifdef USE_X_TOOLKIT
12241 this_window
= XtWindow (f
->output_data
.x
->widget
);
12243 this_window
= FRAME_X_WINDOW (f
);
12246 /* Find the position of the outside upper-left corner of
12247 the inner window, with respect to the outer window.
12248 But do this only if we will need the results. */
12249 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
12254 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
12257 x_clear_errors (FRAME_X_DISPLAY (f
));
12258 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
12260 /* From-window, to-window. */
12262 f
->output_data
.x
->parent_desc
,
12264 /* From-position, to-position. */
12265 0, 0, &win_x
, &win_y
,
12267 /* Child of win. */
12269 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
12271 Window newroot
, newparent
= 0xdeadbeef;
12272 Window
*newchildren
;
12273 unsigned int nchildren
;
12275 if (! XQueryTree (FRAME_X_DISPLAY (f
), this_window
, &newroot
,
12276 &newparent
, &newchildren
, &nchildren
))
12279 XFree ((char *) newchildren
);
12281 f
->output_data
.x
->parent_desc
= newparent
;
12287 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
12291 /* Treat negative positions as relative to the leftmost bottommost
12292 position that fits on the screen. */
12293 if (flags
& XNegative
)
12294 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
12295 - 2 * f
->output_data
.x
->border_width
- win_x
12297 + f
->output_data
.x
->left_pos
);
12300 int height
= PIXEL_HEIGHT (f
);
12302 #if defined USE_X_TOOLKIT && defined USE_MOTIF
12303 /* Something is fishy here. When using Motif, starting Emacs with
12304 `-g -0-0', the frame appears too low by a few pixels.
12306 This seems to be so because initially, while Emacs is starting,
12307 the column widget's height and the frame's pixel height are
12308 different. The column widget's height is the right one. In
12309 later invocations, when Emacs is up, the frame's pixel height
12312 It's not obvious where the initial small difference comes from.
12313 2000-12-01, gerd. */
12315 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
12318 if (flags
& YNegative
)
12319 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
12320 - 2 * f
->output_data
.x
->border_width
12323 + f
->output_data
.x
->top_pos
);
12326 /* The left_pos and top_pos
12327 are now relative to the top and left screen edges,
12328 so the flags should correspond. */
12329 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
12332 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
12333 to really change the position, and 0 when calling from
12334 x_make_frame_visible (in that case, XOFF and YOFF are the current
12335 position values). It is -1 when calling from x_set_frame_parameters,
12336 which means, do adjust for borders but don't change the gravity. */
12339 x_set_offset (f
, xoff
, yoff
, change_gravity
)
12341 register int xoff
, yoff
;
12342 int change_gravity
;
12344 int modified_top
, modified_left
;
12346 if (change_gravity
> 0)
12348 f
->output_data
.x
->top_pos
= yoff
;
12349 f
->output_data
.x
->left_pos
= xoff
;
12350 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
12352 f
->output_data
.x
->size_hint_flags
|= XNegative
;
12354 f
->output_data
.x
->size_hint_flags
|= YNegative
;
12355 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
12357 x_calc_absolute_position (f
);
12360 x_wm_set_size_hint (f
, (long) 0, 0);
12362 modified_left
= f
->output_data
.x
->left_pos
;
12363 modified_top
= f
->output_data
.x
->top_pos
;
12364 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
12365 this seems to be unnecessary and incorrect. rms, 4/17/97. */
12366 /* It is a mystery why we need to add the border_width here
12367 when the frame is already visible, but experiment says we do. */
12368 if (change_gravity
!= 0)
12370 modified_left
+= f
->output_data
.x
->border_width
;
12371 modified_top
+= f
->output_data
.x
->border_width
;
12375 #ifdef USE_X_TOOLKIT
12376 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
12377 modified_left
, modified_top
);
12378 #else /* not USE_X_TOOLKIT */
12379 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
12380 modified_left
, modified_top
);
12381 #endif /* not USE_X_TOOLKIT */
12386 /* Change the size of frame F's X window to COLS/ROWS in the case F
12387 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
12388 top-left-corner window gravity for this size change and subsequent
12389 size changes. Otherwise we leave the window gravity unchanged. */
12392 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
12394 int change_gravity
;
12397 int pixelwidth
, pixelheight
;
12399 check_frame_size (f
, &rows
, &cols
);
12400 f
->output_data
.x
->vertical_scroll_bar_extra
12401 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
12403 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
12404 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
12405 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
12406 f
->output_data
.x
->flags_areas_extra
12407 = FRAME_FLAGS_AREA_WIDTH (f
);
12408 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
12409 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
12411 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
12412 x_wm_set_size_hint (f
, (long) 0, 0);
12414 XSync (FRAME_X_DISPLAY (f
), False
);
12415 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
12416 pixelwidth
, pixelheight
);
12418 /* Now, strictly speaking, we can't be sure that this is accurate,
12419 but the window manager will get around to dealing with the size
12420 change request eventually, and we'll hear how it went when the
12421 ConfigureNotify event gets here.
12423 We could just not bother storing any of this information here,
12424 and let the ConfigureNotify event set everything up, but that
12425 might be kind of confusing to the Lisp code, since size changes
12426 wouldn't be reported in the frame parameters until some random
12427 point in the future when the ConfigureNotify event arrives.
12429 We pass 1 for DELAY since we can't run Lisp code inside of
12431 change_frame_size (f
, rows
, cols
, 0, 1, 0);
12432 PIXEL_WIDTH (f
) = pixelwidth
;
12433 PIXEL_HEIGHT (f
) = pixelheight
;
12435 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
12436 receive in the ConfigureNotify event; if we get what we asked
12437 for, then the event won't cause the screen to become garbaged, so
12438 we have to make sure to do it here. */
12439 SET_FRAME_GARBAGED (f
);
12441 XFlush (FRAME_X_DISPLAY (f
));
12445 /* Call this to change the size of frame F's x-window.
12446 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
12447 for this size change and subsequent size changes.
12448 Otherwise we leave the window gravity unchanged. */
12451 x_set_window_size (f
, change_gravity
, cols
, rows
)
12453 int change_gravity
;
12458 #ifdef USE_X_TOOLKIT
12460 if (f
->output_data
.x
->widget
!= NULL
)
12462 /* The x and y position of the widget is clobbered by the
12463 call to XtSetValues within EmacsFrameSetCharSize.
12464 This is a real kludge, but I don't understand Xt so I can't
12465 figure out a correct fix. Can anyone else tell me? -- rms. */
12466 int xpos
= f
->output_data
.x
->widget
->core
.x
;
12467 int ypos
= f
->output_data
.x
->widget
->core
.y
;
12468 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
12469 f
->output_data
.x
->widget
->core
.x
= xpos
;
12470 f
->output_data
.x
->widget
->core
.y
= ypos
;
12473 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
12475 #else /* not USE_X_TOOLKIT */
12477 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
12479 #endif /* not USE_X_TOOLKIT */
12481 /* If cursor was outside the new size, mark it as off. */
12482 mark_window_cursors_off (XWINDOW (f
->root_window
));
12484 /* Clear out any recollection of where the mouse highlighting was,
12485 since it might be in a place that's outside the new frame size.
12486 Actually checking whether it is outside is a pain in the neck,
12487 so don't try--just let the highlighting be done afresh with new size. */
12488 cancel_mouse_face (f
);
12493 /* Mouse warping. */
12496 x_set_mouse_position (f
, x
, y
)
12502 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
12503 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
12505 if (pix_x
< 0) pix_x
= 0;
12506 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
12508 if (pix_y
< 0) pix_y
= 0;
12509 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
12513 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
12514 0, 0, 0, 0, pix_x
, pix_y
);
12518 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
12521 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
12527 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
12528 0, 0, 0, 0, pix_x
, pix_y
);
12532 /* focus shifting, raising and lowering. */
12535 x_focus_on_frame (f
)
12538 #if 0 /* This proves to be unpleasant. */
12542 /* I don't think that the ICCCM allows programs to do things like this
12543 without the interaction of the window manager. Whatever you end up
12544 doing with this code, do it to x_unfocus_frame too. */
12545 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
12546 RevertToPointerRoot
, CurrentTime
);
12551 x_unfocus_frame (f
)
12555 /* Look at the remarks in x_focus_on_frame. */
12556 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
12557 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
12558 RevertToPointerRoot
, CurrentTime
);
12562 /* Raise frame F. */
12568 if (f
->async_visible
)
12571 #ifdef USE_X_TOOLKIT
12572 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
12573 #else /* not USE_X_TOOLKIT */
12574 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12575 #endif /* not USE_X_TOOLKIT */
12576 XFlush (FRAME_X_DISPLAY (f
));
12581 /* Lower frame F. */
12587 if (f
->async_visible
)
12590 #ifdef USE_X_TOOLKIT
12591 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
12592 #else /* not USE_X_TOOLKIT */
12593 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12594 #endif /* not USE_X_TOOLKIT */
12595 XFlush (FRAME_X_DISPLAY (f
));
12601 XTframe_raise_lower (f
, raise_flag
)
12611 /* Change of visibility. */
12613 /* This tries to wait until the frame is really visible.
12614 However, if the window manager asks the user where to position
12615 the frame, this will return before the user finishes doing that.
12616 The frame will not actually be visible at that time,
12617 but it will become visible later when the window manager
12618 finishes with it. */
12621 x_make_frame_visible (f
)
12625 int original_top
, original_left
;
12626 int retry_count
= 2;
12632 type
= x_icon_type (f
);
12634 x_bitmap_icon (f
, type
);
12636 if (! FRAME_VISIBLE_P (f
))
12638 /* We test FRAME_GARBAGED_P here to make sure we don't
12639 call x_set_offset a second time
12640 if we get to x_make_frame_visible a second time
12641 before the window gets really visible. */
12642 if (! FRAME_ICONIFIED_P (f
)
12643 && ! f
->output_data
.x
->asked_for_visible
)
12644 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
12646 f
->output_data
.x
->asked_for_visible
= 1;
12648 if (! EQ (Vx_no_window_manager
, Qt
))
12649 x_wm_set_window_state (f
, NormalState
);
12650 #ifdef USE_X_TOOLKIT
12651 /* This was XtPopup, but that did nothing for an iconified frame. */
12652 XtMapWidget (f
->output_data
.x
->widget
);
12653 #else /* not USE_X_TOOLKIT */
12654 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12655 #endif /* not USE_X_TOOLKIT */
12656 #if 0 /* This seems to bring back scroll bars in the wrong places
12657 if the window configuration has changed. They seem
12658 to come back ok without this. */
12659 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
12660 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12664 XFlush (FRAME_X_DISPLAY (f
));
12666 /* Synchronize to ensure Emacs knows the frame is visible
12667 before we do anything else. We do this loop with input not blocked
12668 so that incoming events are handled. */
12672 /* This must be before UNBLOCK_INPUT
12673 since events that arrive in response to the actions above
12674 will set it when they are handled. */
12675 int previously_visible
= f
->output_data
.x
->has_been_visible
;
12677 original_left
= f
->output_data
.x
->left_pos
;
12678 original_top
= f
->output_data
.x
->top_pos
;
12680 /* This must come after we set COUNT. */
12683 /* We unblock here so that arriving X events are processed. */
12685 /* Now move the window back to where it was "supposed to be".
12686 But don't do it if the gravity is negative.
12687 When the gravity is negative, this uses a position
12688 that is 3 pixels too low. Perhaps that's really the border width.
12690 Don't do this if the window has never been visible before,
12691 because the window manager may choose the position
12692 and we don't want to override it. */
12694 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
12695 && f
->output_data
.x
->win_gravity
== NorthWestGravity
12696 && previously_visible
)
12700 unsigned int width
, height
, border
, depth
;
12704 /* On some window managers (such as FVWM) moving an existing
12705 window, even to the same place, causes the window manager
12706 to introduce an offset. This can cause the window to move
12707 to an unexpected location. Check the geometry (a little
12708 slow here) and then verify that the window is in the right
12709 place. If the window is not in the right place, move it
12710 there, and take the potential window manager hit. */
12711 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
12712 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
12714 if (original_left
!= x
|| original_top
!= y
)
12715 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
12716 original_left
, original_top
);
12721 XSETFRAME (frame
, f
);
12723 /* Wait until the frame is visible. Process X events until a
12724 MapNotify event has been seen, or until we think we won't get a
12725 MapNotify at all.. */
12726 for (count
= input_signal_count
+ 10;
12727 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
12729 /* Force processing of queued events. */
12732 /* Machines that do polling rather than SIGIO have been
12733 observed to go into a busy-wait here. So we'll fake an
12734 alarm signal to let the handler know that there's something
12735 to be read. We used to raise a real alarm, but it seems
12736 that the handler isn't always enabled here. This is
12738 if (input_polling_used ())
12740 /* It could be confusing if a real alarm arrives while
12741 processing the fake one. Turn it off and let the
12742 handler reset it. */
12743 extern void poll_for_input_1
P_ ((void));
12744 int old_poll_suppress_count
= poll_suppress_count
;
12745 poll_suppress_count
= 1;
12746 poll_for_input_1 ();
12747 poll_suppress_count
= old_poll_suppress_count
;
12750 /* See if a MapNotify event has been processed. */
12751 FRAME_SAMPLE_VISIBILITY (f
);
12756 (let ((f (selected-frame)))
12760 the frame is not raised with various window managers on
12761 FreeBSD, Linux and Solaris. It turns out that, for some
12762 unknown reason, the call to XtMapWidget is completely ignored.
12763 Mapping the widget a second time works. */
12765 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
12770 /* Change from mapped state to withdrawn state. */
12772 /* Make the frame visible (mapped and not iconified). */
12775 x_make_frame_invisible (f
)
12780 #ifdef USE_X_TOOLKIT
12781 /* Use the frame's outermost window, not the one we normally draw on. */
12782 window
= XtWindow (f
->output_data
.x
->widget
);
12783 #else /* not USE_X_TOOLKIT */
12784 window
= FRAME_X_WINDOW (f
);
12785 #endif /* not USE_X_TOOLKIT */
12787 /* Don't keep the highlight on an invisible frame. */
12788 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
12789 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
12791 #if 0/* This might add unreliability; I don't trust it -- rms. */
12792 if (! f
->async_visible
&& ! f
->async_iconified
)
12798 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
12799 that the current position of the window is user-specified, rather than
12800 program-specified, so that when the window is mapped again, it will be
12801 placed at the same location, without forcing the user to position it
12802 by hand again (they have already done that once for this window.) */
12803 x_wm_set_size_hint (f
, (long) 0, 1);
12807 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
12808 DefaultScreen (FRAME_X_DISPLAY (f
))))
12810 UNBLOCK_INPUT_RESIGNAL
;
12811 error ("Can't notify window manager of window withdrawal");
12813 #else /* ! defined (HAVE_X11R4) */
12815 /* Tell the window manager what we're going to do. */
12816 if (! EQ (Vx_no_window_manager
, Qt
))
12820 unmap
.xunmap
.type
= UnmapNotify
;
12821 unmap
.xunmap
.window
= window
;
12822 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
12823 unmap
.xunmap
.from_configure
= False
;
12824 if (! XSendEvent (FRAME_X_DISPLAY (f
),
12825 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
12827 SubstructureRedirectMaskSubstructureNotifyMask
,
12830 UNBLOCK_INPUT_RESIGNAL
;
12831 error ("Can't notify window manager of withdrawal");
12835 /* Unmap the window ourselves. Cheeky! */
12836 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
12837 #endif /* ! defined (HAVE_X11R4) */
12839 /* We can't distinguish this from iconification
12840 just by the event that we get from the server.
12841 So we can't win using the usual strategy of letting
12842 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
12843 and synchronize with the server to make sure we agree. */
12845 FRAME_ICONIFIED_P (f
) = 0;
12846 f
->async_visible
= 0;
12847 f
->async_iconified
= 0;
12854 /* Change window state from mapped to iconified. */
12857 x_iconify_frame (f
)
12863 /* Don't keep the highlight on an invisible frame. */
12864 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
12865 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
12867 if (f
->async_iconified
)
12872 FRAME_SAMPLE_VISIBILITY (f
);
12874 type
= x_icon_type (f
);
12876 x_bitmap_icon (f
, type
);
12878 #ifdef USE_X_TOOLKIT
12880 if (! FRAME_VISIBLE_P (f
))
12882 if (! EQ (Vx_no_window_manager
, Qt
))
12883 x_wm_set_window_state (f
, IconicState
);
12884 /* This was XtPopup, but that did nothing for an iconified frame. */
12885 XtMapWidget (f
->output_data
.x
->widget
);
12886 /* The server won't give us any event to indicate
12887 that an invisible frame was changed to an icon,
12888 so we have to record it here. */
12891 f
->async_iconified
= 1;
12892 f
->async_visible
= 0;
12897 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
12898 XtWindow (f
->output_data
.x
->widget
),
12899 DefaultScreen (FRAME_X_DISPLAY (f
)));
12903 error ("Can't notify window manager of iconification");
12905 f
->async_iconified
= 1;
12906 f
->async_visible
= 0;
12910 XFlush (FRAME_X_DISPLAY (f
));
12912 #else /* not USE_X_TOOLKIT */
12914 /* Make sure the X server knows where the window should be positioned,
12915 in case the user deiconifies with the window manager. */
12916 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
12917 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
12919 /* Since we don't know which revision of X we're running, we'll use both
12920 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
12922 /* X11R4: send a ClientMessage to the window manager using the
12923 WM_CHANGE_STATE type. */
12927 message
.xclient
.window
= FRAME_X_WINDOW (f
);
12928 message
.xclient
.type
= ClientMessage
;
12929 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
12930 message
.xclient
.format
= 32;
12931 message
.xclient
.data
.l
[0] = IconicState
;
12933 if (! XSendEvent (FRAME_X_DISPLAY (f
),
12934 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
12936 SubstructureRedirectMask
| SubstructureNotifyMask
,
12939 UNBLOCK_INPUT_RESIGNAL
;
12940 error ("Can't notify window manager of iconification");
12944 /* X11R3: set the initial_state field of the window manager hints to
12946 x_wm_set_window_state (f
, IconicState
);
12948 if (!FRAME_VISIBLE_P (f
))
12950 /* If the frame was withdrawn, before, we must map it. */
12951 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12954 f
->async_iconified
= 1;
12955 f
->async_visible
= 0;
12957 XFlush (FRAME_X_DISPLAY (f
));
12959 #endif /* not USE_X_TOOLKIT */
12963 /* Free X resources of frame F. */
12966 x_free_frame_resources (f
)
12969 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12973 /* If a display connection is dead, don't try sending more
12974 commands to the X server. */
12975 if (dpyinfo
->display
)
12977 if (f
->output_data
.x
->icon_desc
)
12978 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
12982 free_frame_xic (f
);
12985 if (FRAME_X_WINDOW (f
))
12986 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12988 #ifdef USE_X_TOOLKIT
12989 if (f
->output_data
.x
->widget
)
12991 XtDestroyWidget (f
->output_data
.x
->widget
);
12992 f
->output_data
.x
->widget
= NULL
;
12994 free_frame_menubar (f
);
12995 #endif /* USE_X_TOOLKIT */
12997 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
12998 unload_color (f
, f
->output_data
.x
->background_pixel
);
12999 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
13000 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
13001 unload_color (f
, f
->output_data
.x
->border_pixel
);
13002 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
13004 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
13005 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
13006 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
13007 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
13008 if (f
->output_data
.x
->white_relief
.allocated_p
)
13009 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
13010 if (f
->output_data
.x
->black_relief
.allocated_p
)
13011 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
13013 if (FRAME_FACE_CACHE (f
))
13014 free_frame_faces (f
);
13017 XFlush (FRAME_X_DISPLAY (f
));
13020 if (f
->output_data
.x
->saved_menu_event
)
13021 xfree (f
->output_data
.x
->saved_menu_event
);
13023 xfree (f
->output_data
.x
);
13024 f
->output_data
.x
= NULL
;
13026 if (f
== dpyinfo
->x_focus_frame
)
13027 dpyinfo
->x_focus_frame
= 0;
13028 if (f
== dpyinfo
->x_focus_event_frame
)
13029 dpyinfo
->x_focus_event_frame
= 0;
13030 if (f
== dpyinfo
->x_highlight_frame
)
13031 dpyinfo
->x_highlight_frame
= 0;
13033 if (f
== dpyinfo
->mouse_face_mouse_frame
)
13035 dpyinfo
->mouse_face_beg_row
13036 = dpyinfo
->mouse_face_beg_col
= -1;
13037 dpyinfo
->mouse_face_end_row
13038 = dpyinfo
->mouse_face_end_col
= -1;
13039 dpyinfo
->mouse_face_window
= Qnil
;
13040 dpyinfo
->mouse_face_deferred_gc
= 0;
13041 dpyinfo
->mouse_face_mouse_frame
= 0;
13048 /* Destroy the X window of frame F. */
13051 x_destroy_window (f
)
13054 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13056 /* If a display connection is dead, don't try sending more
13057 commands to the X server. */
13058 if (dpyinfo
->display
!= 0)
13059 x_free_frame_resources (f
);
13061 dpyinfo
->reference_count
--;
13065 /* Setting window manager hints. */
13067 /* Set the normal size hints for the window manager, for frame F.
13068 FLAGS is the flags word to use--or 0 meaning preserve the flags
13069 that the window now has.
13070 If USER_POSITION is nonzero, we set the USPosition
13071 flag (this is useful when FLAGS is 0). */
13074 x_wm_set_size_hint (f
, flags
, user_position
)
13079 XSizeHints size_hints
;
13081 #ifdef USE_X_TOOLKIT
13084 Dimension widget_width
, widget_height
;
13085 Window window
= XtWindow (f
->output_data
.x
->widget
);
13086 #else /* not USE_X_TOOLKIT */
13087 Window window
= FRAME_X_WINDOW (f
);
13088 #endif /* not USE_X_TOOLKIT */
13090 /* Setting PMaxSize caused various problems. */
13091 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
13093 size_hints
.x
= f
->output_data
.x
->left_pos
;
13094 size_hints
.y
= f
->output_data
.x
->top_pos
;
13096 #ifdef USE_X_TOOLKIT
13097 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
13098 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
13099 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
13100 size_hints
.height
= widget_height
;
13101 size_hints
.width
= widget_width
;
13102 #else /* not USE_X_TOOLKIT */
13103 size_hints
.height
= PIXEL_HEIGHT (f
);
13104 size_hints
.width
= PIXEL_WIDTH (f
);
13105 #endif /* not USE_X_TOOLKIT */
13107 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
13108 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
13109 size_hints
.max_width
13110 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
13111 size_hints
.max_height
13112 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
13114 /* Calculate the base and minimum sizes.
13116 (When we use the X toolkit, we don't do it here.
13117 Instead we copy the values that the widgets are using, below.) */
13118 #ifndef USE_X_TOOLKIT
13120 int base_width
, base_height
;
13121 int min_rows
= 0, min_cols
= 0;
13123 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
13124 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
13126 check_frame_size (f
, &min_rows
, &min_cols
);
13128 /* The window manager uses the base width hints to calculate the
13129 current number of rows and columns in the frame while
13130 resizing; min_width and min_height aren't useful for this
13131 purpose, since they might not give the dimensions for a
13132 zero-row, zero-column frame.
13134 We use the base_width and base_height members if we have
13135 them; otherwise, we set the min_width and min_height members
13136 to the size for a zero x zero frame. */
13139 size_hints
.flags
|= PBaseSize
;
13140 size_hints
.base_width
= base_width
;
13141 size_hints
.base_height
= base_height
;
13142 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
13143 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
13145 size_hints
.min_width
= base_width
;
13146 size_hints
.min_height
= base_height
;
13150 /* If we don't need the old flags, we don't need the old hint at all. */
13153 size_hints
.flags
|= flags
;
13156 #endif /* not USE_X_TOOLKIT */
13159 XSizeHints hints
; /* Sometimes I hate X Windows... */
13160 long supplied_return
;
13164 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
13167 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
13170 #ifdef USE_X_TOOLKIT
13171 size_hints
.base_height
= hints
.base_height
;
13172 size_hints
.base_width
= hints
.base_width
;
13173 size_hints
.min_height
= hints
.min_height
;
13174 size_hints
.min_width
= hints
.min_width
;
13178 size_hints
.flags
|= flags
;
13183 if (hints
.flags
& PSize
)
13184 size_hints
.flags
|= PSize
;
13185 if (hints
.flags
& PPosition
)
13186 size_hints
.flags
|= PPosition
;
13187 if (hints
.flags
& USPosition
)
13188 size_hints
.flags
|= USPosition
;
13189 if (hints
.flags
& USSize
)
13190 size_hints
.flags
|= USSize
;
13194 #ifndef USE_X_TOOLKIT
13199 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
13200 size_hints
.flags
|= PWinGravity
;
13204 size_hints
.flags
&= ~ PPosition
;
13205 size_hints
.flags
|= USPosition
;
13207 #endif /* PWinGravity */
13210 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
13212 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
13216 /* Used for IconicState or NormalState */
13219 x_wm_set_window_state (f
, state
)
13223 #ifdef USE_X_TOOLKIT
13226 XtSetArg (al
[0], XtNinitialState
, state
);
13227 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
13228 #else /* not USE_X_TOOLKIT */
13229 Window window
= FRAME_X_WINDOW (f
);
13231 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
13232 f
->output_data
.x
->wm_hints
.initial_state
= state
;
13234 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
13235 #endif /* not USE_X_TOOLKIT */
13239 x_wm_set_icon_pixmap (f
, pixmap_id
)
13243 Pixmap icon_pixmap
;
13245 #ifndef USE_X_TOOLKIT
13246 Window window
= FRAME_X_WINDOW (f
);
13251 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
13252 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
13256 /* It seems there is no way to turn off use of an icon pixmap.
13257 The following line does it, only if no icon has yet been created,
13258 for some window managers. But with mwm it crashes.
13259 Some people say it should clear the IconPixmapHint bit in this case,
13260 but that doesn't work, and the X consortium said it isn't the
13261 right thing at all. Since there is no way to win,
13262 best to explicitly give up. */
13264 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
13270 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
13274 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
13275 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
13278 #else /* not USE_X_TOOLKIT */
13280 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
13281 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
13283 #endif /* not USE_X_TOOLKIT */
13287 x_wm_set_icon_position (f
, icon_x
, icon_y
)
13289 int icon_x
, icon_y
;
13291 #ifdef USE_X_TOOLKIT
13292 Window window
= XtWindow (f
->output_data
.x
->widget
);
13294 Window window
= FRAME_X_WINDOW (f
);
13297 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
13298 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
13299 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
13301 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
13305 /***********************************************************************
13307 ***********************************************************************/
13309 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
13312 x_get_font_info (f
, font_idx
)
13316 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
13320 /* Return a list of names of available fonts matching PATTERN on frame F.
13322 If SIZE is > 0, it is the size (maximum bounds width) of fonts
13325 SIZE < 0 means include scalable fonts.
13327 Frame F null means we have not yet created any frame on X, and
13328 consult the first display in x_display_list. MAXNAMES sets a limit
13329 on how many fonts to match. */
13332 x_list_fonts (f
, pattern
, size
, maxnames
)
13334 Lisp_Object pattern
;
13338 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
13339 Lisp_Object tem
, second_best
;
13340 struct x_display_info
*dpyinfo
13341 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
13342 Display
*dpy
= dpyinfo
->display
;
13343 int try_XLoadQueryFont
= 0;
13345 int allow_scalable_fonts_p
= 0;
13349 allow_scalable_fonts_p
= 1;
13353 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
13354 if (NILP (patterns
))
13355 patterns
= Fcons (pattern
, Qnil
);
13357 if (maxnames
== 1 && !size
)
13358 /* We can return any single font matching PATTERN. */
13359 try_XLoadQueryFont
= 1;
13361 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
13364 char **names
= NULL
;
13366 pattern
= XCAR (patterns
);
13367 /* See if we cached the result for this particular query.
13368 The cache is an alist of the form:
13369 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
13370 tem
= XCDR (dpyinfo
->name_list_element
);
13371 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
13372 allow_scalable_fonts_p
? Qt
: Qnil
);
13373 list
= Fassoc (key
, tem
);
13376 list
= Fcdr_safe (list
);
13377 /* We have a cashed list. Don't have to get the list again. */
13381 /* At first, put PATTERN in the cache. */
13384 count
= x_catch_errors (dpy
);
13386 if (try_XLoadQueryFont
)
13389 unsigned long value
;
13391 font
= XLoadQueryFont (dpy
, XSTRING (pattern
)->data
);
13392 if (x_had_errors_p (dpy
))
13394 /* This error is perhaps due to insufficient memory on X
13395 server. Let's just ignore it. */
13397 x_clear_errors (dpy
);
13401 && XGetFontProperty (font
, XA_FONT
, &value
))
13403 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
13404 int len
= strlen (name
);
13407 /* If DXPC (a Differential X Protocol Compressor)
13408 Ver.3.7 is running, XGetAtomName will return null
13409 string. We must avoid such a name. */
13411 try_XLoadQueryFont
= 0;
13415 names
= (char **) alloca (sizeof (char *));
13416 /* Some systems only allow alloca assigned to a
13418 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
13419 bcopy (name
, names
[0], len
+ 1);
13424 try_XLoadQueryFont
= 0;
13427 XFreeFont (dpy
, font
);
13430 if (!try_XLoadQueryFont
)
13432 /* We try at least 10 fonts because XListFonts will return
13433 auto-scaled fonts at the head. */
13434 names
= XListFonts (dpy
, XSTRING (pattern
)->data
, max (maxnames
, 10),
13436 if (x_had_errors_p (dpy
))
13438 /* This error is perhaps due to insufficient memory on X
13439 server. Let's just ignore it. */
13441 x_clear_errors (dpy
);
13445 x_uncatch_errors (dpy
, count
);
13452 /* Make a list of all the fonts we got back.
13453 Store that in the font cache for the display. */
13454 for (i
= 0; i
< num_fonts
; i
++)
13457 char *p
= names
[i
];
13458 int average_width
= -1, dashes
= 0;
13460 /* Count the number of dashes in NAMES[I]. If there are
13461 14 dashes, and the field value following 12th dash
13462 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
13463 is usually too ugly to be used for editing. Let's
13469 if (dashes
== 7) /* PIXEL_SIZE field */
13471 else if (dashes
== 12) /* AVERAGE_WIDTH field */
13472 average_width
= atoi (p
);
13475 if (allow_scalable_fonts_p
13476 || dashes
< 14 || average_width
!= 0)
13478 tem
= build_string (names
[i
]);
13479 if (NILP (Fassoc (tem
, list
)))
13481 if (STRINGP (Vx_pixel_size_width_font_regexp
)
13482 && ((fast_c_string_match_ignore_case
13483 (Vx_pixel_size_width_font_regexp
, names
[i
]))
13485 /* We can set the value of PIXEL_SIZE to the
13486 width of this font. */
13487 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
13489 /* For the moment, width is not known. */
13490 list
= Fcons (Fcons (tem
, Qnil
), list
);
13495 if (!try_XLoadQueryFont
)
13498 XFreeFontNames (names
);
13503 /* Now store the result in the cache. */
13504 XCDR (dpyinfo
->name_list_element
)
13505 = Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
));
13508 if (NILP (list
)) continue; /* Try the remaining alternatives. */
13510 newlist
= second_best
= Qnil
;
13511 /* Make a list of the fonts that have the right width. */
13512 for (; CONSP (list
); list
= XCDR (list
))
13518 if (!CONSP (tem
) || NILP (XCAR (tem
)))
13522 newlist
= Fcons (XCAR (tem
), newlist
);
13526 if (!INTEGERP (XCDR (tem
)))
13528 /* Since we have not yet known the size of this font, we
13529 must try slow function call XLoadQueryFont. */
13530 XFontStruct
*thisinfo
;
13533 count
= x_catch_errors (dpy
);
13534 thisinfo
= XLoadQueryFont (dpy
,
13535 XSTRING (XCAR (tem
))->data
);
13536 if (x_had_errors_p (dpy
))
13538 /* This error is perhaps due to insufficient memory on X
13539 server. Let's just ignore it. */
13541 x_clear_errors (dpy
);
13543 x_uncatch_errors (dpy
, count
);
13549 = (thisinfo
->min_bounds
.width
== 0
13551 : make_number (thisinfo
->max_bounds
.width
));
13553 XFreeFont (dpy
, thisinfo
);
13557 /* For unknown reason, the previous call of XListFont had
13558 returned a font which can't be opened. Record the size
13559 as 0 not to try to open it again. */
13560 XCDR (tem
) = make_number (0);
13563 found_size
= XINT (XCDR (tem
));
13564 if (found_size
== size
)
13565 newlist
= Fcons (XCAR (tem
), newlist
);
13566 else if (found_size
> 0)
13568 if (NILP (second_best
))
13570 else if (found_size
< size
)
13572 if (XINT (XCDR (second_best
)) > size
13573 || XINT (XCDR (second_best
)) < found_size
)
13578 if (XINT (XCDR (second_best
)) > size
13579 && XINT (XCDR (second_best
)) > found_size
)
13584 if (!NILP (newlist
))
13586 else if (!NILP (second_best
))
13588 newlist
= Fcons (XCAR (second_best
), Qnil
);
13599 /* Check that FONT is valid on frame F. It is if it can be found in F's
13603 x_check_font (f
, font
)
13608 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13610 xassert (font
!= NULL
);
13612 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
13613 if (dpyinfo
->font_table
[i
].name
13614 && font
== dpyinfo
->font_table
[i
].font
)
13617 xassert (i
< dpyinfo
->n_fonts
);
13620 #endif /* GLYPH_DEBUG != 0 */
13622 /* Set *W to the minimum width, *H to the minimum font height of FONT.
13623 Note: There are (broken) X fonts out there with invalid XFontStruct
13624 min_bounds contents. For example, handa@etl.go.jp reports that
13625 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
13626 have font->min_bounds.width == 0. */
13629 x_font_min_bounds (font
, w
, h
)
13633 *h
= FONT_HEIGHT (font
);
13634 *w
= font
->min_bounds
.width
;
13636 /* Try to handle the case where FONT->min_bounds has invalid
13637 contents. Since the only font known to have invalid min_bounds
13638 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
13640 *w
= font
->max_bounds
.width
;
13644 /* Compute the smallest character width and smallest font height over
13645 all fonts available on frame F. Set the members smallest_char_width
13646 and smallest_font_height in F's x_display_info structure to
13647 the values computed. Value is non-zero if smallest_font_height or
13648 smallest_char_width become smaller than they were before. */
13651 x_compute_min_glyph_bounds (f
)
13655 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13657 int old_width
= dpyinfo
->smallest_char_width
;
13658 int old_height
= dpyinfo
->smallest_font_height
;
13660 dpyinfo
->smallest_font_height
= 100000;
13661 dpyinfo
->smallest_char_width
= 100000;
13663 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
13664 if (dpyinfo
->font_table
[i
].name
)
13666 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
13669 font
= (XFontStruct
*) fontp
->font
;
13670 xassert (font
!= (XFontStruct
*) ~0);
13671 x_font_min_bounds (font
, &w
, &h
);
13673 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
13674 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
13677 xassert (dpyinfo
->smallest_char_width
> 0
13678 && dpyinfo
->smallest_font_height
> 0);
13680 return (dpyinfo
->n_fonts
== 1
13681 || dpyinfo
->smallest_char_width
< old_width
13682 || dpyinfo
->smallest_font_height
< old_height
);
13686 /* Load font named FONTNAME of the size SIZE for frame F, and return a
13687 pointer to the structure font_info while allocating it dynamically.
13688 If SIZE is 0, load any size of font.
13689 If loading is failed, return NULL. */
13692 x_load_font (f
, fontname
, size
)
13694 register char *fontname
;
13697 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13698 Lisp_Object font_names
;
13701 /* Get a list of all the fonts that match this name. Once we
13702 have a list of matching fonts, we compare them against the fonts
13703 we already have by comparing names. */
13704 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
13706 if (!NILP (font_names
))
13711 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
13712 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
13713 if (dpyinfo
->font_table
[i
].name
13714 && (!strcmp (dpyinfo
->font_table
[i
].name
,
13715 XSTRING (XCAR (tail
))->data
)
13716 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
13717 XSTRING (XCAR (tail
))->data
)))
13718 return (dpyinfo
->font_table
+ i
);
13721 /* Load the font and add it to the table. */
13725 struct font_info
*fontp
;
13726 unsigned long value
;
13729 /* If we have found fonts by x_list_font, load one of them. If
13730 not, we still try to load a font by the name given as FONTNAME
13731 because XListFonts (called in x_list_font) of some X server has
13732 a bug of not finding a font even if the font surely exists and
13733 is loadable by XLoadQueryFont. */
13734 if (size
> 0 && !NILP (font_names
))
13735 fontname
= (char *) XSTRING (XCAR (font_names
))->data
;
13738 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
13739 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
13740 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
13742 /* This error is perhaps due to insufficient memory on X
13743 server. Let's just ignore it. */
13745 x_clear_errors (FRAME_X_DISPLAY (f
));
13747 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
13752 /* Find a free slot in the font table. */
13753 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
13754 if (dpyinfo
->font_table
[i
].name
== NULL
)
13757 /* If no free slot found, maybe enlarge the font table. */
13758 if (i
== dpyinfo
->n_fonts
13759 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
13762 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
13763 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
13764 dpyinfo
->font_table
13765 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
13768 fontp
= dpyinfo
->font_table
+ i
;
13769 if (i
== dpyinfo
->n_fonts
)
13770 ++dpyinfo
->n_fonts
;
13772 /* Now fill in the slots of *FONTP. */
13774 fontp
->font
= font
;
13775 fontp
->font_idx
= i
;
13776 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
13777 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
13779 /* Try to get the full name of FONT. Put it in FULL_NAME. */
13781 if (XGetFontProperty (font
, XA_FONT
, &value
))
13783 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
13787 /* Count the number of dashes in the "full name".
13788 If it is too few, this isn't really the font's full name,
13790 In X11R4, the fonts did not come with their canonical names
13801 full_name
= (char *) xmalloc (p
- name
+ 1);
13802 bcopy (name
, full_name
, p
- name
+ 1);
13808 if (full_name
!= 0)
13809 fontp
->full_name
= full_name
;
13811 fontp
->full_name
= fontp
->name
;
13813 fontp
->size
= font
->max_bounds
.width
;
13814 fontp
->height
= FONT_HEIGHT (font
);
13816 if (NILP (font_names
))
13818 /* We come here because of a bug of XListFonts mentioned at
13819 the head of this block. Let's store this information in
13820 the cache for x_list_fonts. */
13821 Lisp_Object lispy_name
= build_string (fontname
);
13822 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
13823 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
13826 XCDR (dpyinfo
->name_list_element
)
13827 = Fcons (Fcons (key
,
13828 Fcons (Fcons (lispy_full_name
,
13829 make_number (fontp
->size
)),
13831 XCDR (dpyinfo
->name_list_element
));
13834 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
13836 XCDR (dpyinfo
->name_list_element
)
13837 = Fcons (Fcons (key
,
13838 Fcons (Fcons (lispy_full_name
,
13839 make_number (fontp
->size
)),
13841 XCDR (dpyinfo
->name_list_element
));
13845 /* The slot `encoding' specifies how to map a character
13846 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
13847 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
13848 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
13849 2:0xA020..0xFF7F). For the moment, we don't know which charset
13850 uses this font. So, we set information in fontp->encoding[1]
13851 which is never used by any charset. If mapping can't be
13852 decided, set FONT_ENCODING_NOT_DECIDED. */
13854 = (font
->max_byte1
== 0
13856 ? (font
->min_char_or_byte2
< 0x80
13857 ? (font
->max_char_or_byte2
< 0x80
13858 ? 0 /* 0x20..0x7F */
13859 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
13860 : 1) /* 0xA0..0xFF */
13862 : (font
->min_byte1
< 0x80
13863 ? (font
->max_byte1
< 0x80
13864 ? (font
->min_char_or_byte2
< 0x80
13865 ? (font
->max_char_or_byte2
< 0x80
13866 ? 0 /* 0x2020..0x7F7F */
13867 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
13868 : 3) /* 0x20A0..0x7FFF */
13869 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
13870 : (font
->min_char_or_byte2
< 0x80
13871 ? (font
->max_char_or_byte2
< 0x80
13872 ? 2 /* 0xA020..0xFF7F */
13873 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
13874 : 1))); /* 0xA0A0..0xFFFF */
13876 fontp
->baseline_offset
13877 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
13878 ? (long) value
: 0);
13879 fontp
->relative_compose
13880 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
13881 ? (long) value
: 0);
13882 fontp
->default_ascent
13883 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
13884 ? (long) value
: 0);
13886 /* Set global flag fonts_changed_p to non-zero if the font loaded
13887 has a character with a smaller width than any other character
13888 before, or if the font loaded has a smalle>r height than any
13889 other font loaded before. If this happens, it will make a
13890 glyph matrix reallocation necessary. */
13891 fonts_changed_p
= x_compute_min_glyph_bounds (f
);
13898 /* Return a pointer to struct font_info of a font named FONTNAME for
13899 frame F. If no such font is loaded, return NULL. */
13902 x_query_font (f
, fontname
)
13904 register char *fontname
;
13906 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13909 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
13910 if (dpyinfo
->font_table
[i
].name
13911 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
13912 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
13913 return (dpyinfo
->font_table
+ i
);
13918 /* Find a CCL program for a font specified by FONTP, and set the member
13919 `encoder' of the structure. */
13922 x_find_ccl_program (fontp
)
13923 struct font_info
*fontp
;
13925 Lisp_Object list
, elt
;
13928 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
13932 && STRINGP (XCAR (elt
))
13933 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
13935 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
13942 struct ccl_program
*ccl
13943 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
13945 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
13948 fontp
->font_encoder
= ccl
;
13954 /***********************************************************************
13956 ***********************************************************************/
13958 #ifdef USE_X_TOOLKIT
13959 static XrmOptionDescRec emacs_options
[] = {
13960 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
13961 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
13963 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
13964 XrmoptionSepArg
, NULL
},
13965 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
13967 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13968 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13969 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13970 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
13971 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
13972 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
13973 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
13975 #endif /* USE_X_TOOLKIT */
13977 static int x_initialized
;
13979 #ifdef MULTI_KBOARD
13980 /* Test whether two display-name strings agree up to the dot that separates
13981 the screen number from the server number. */
13983 same_x_server (name1
, name2
)
13984 char *name1
, *name2
;
13986 int seen_colon
= 0;
13987 unsigned char *system_name
= XSTRING (Vsystem_name
)->data
;
13988 int system_name_length
= strlen (system_name
);
13989 int length_until_period
= 0;
13991 while (system_name
[length_until_period
] != 0
13992 && system_name
[length_until_period
] != '.')
13993 length_until_period
++;
13995 /* Treat `unix' like an empty host name. */
13996 if (! strncmp (name1
, "unix:", 5))
13998 if (! strncmp (name2
, "unix:", 5))
14000 /* Treat this host's name like an empty host name. */
14001 if (! strncmp (name1
, system_name
, system_name_length
)
14002 && name1
[system_name_length
] == ':')
14003 name1
+= system_name_length
;
14004 if (! strncmp (name2
, system_name
, system_name_length
)
14005 && name2
[system_name_length
] == ':')
14006 name2
+= system_name_length
;
14007 /* Treat this host's domainless name like an empty host name. */
14008 if (! strncmp (name1
, system_name
, length_until_period
)
14009 && name1
[length_until_period
] == ':')
14010 name1
+= length_until_period
;
14011 if (! strncmp (name2
, system_name
, length_until_period
)
14012 && name2
[length_until_period
] == ':')
14013 name2
+= length_until_period
;
14015 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
14019 if (seen_colon
&& *name1
== '.')
14023 && (*name1
== '.' || *name1
== '\0')
14024 && (*name2
== '.' || *name2
== '\0'));
14028 struct x_display_info
*
14029 x_term_init (display_name
, xrm_option
, resource_name
)
14030 Lisp_Object display_name
;
14032 char *resource_name
;
14036 struct x_display_info
*dpyinfo
;
14041 if (!x_initialized
)
14047 #ifdef USE_X_TOOLKIT
14048 /* weiner@footloose.sps.mot.com reports that this causes
14050 X protocol error: BadAtom (invalid Atom parameter)
14051 on protocol request 18skiloaf.
14052 So let's not use it until R6. */
14053 #ifdef HAVE_X11XTR6
14054 XtSetLanguageProc (NULL
, NULL
, NULL
);
14065 argv
[argc
++] = "-xrm";
14066 argv
[argc
++] = xrm_option
;
14068 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
14069 resource_name
, EMACS_CLASS
,
14070 emacs_options
, XtNumber (emacs_options
),
14073 #ifdef HAVE_X11XTR6
14074 /* I think this is to compensate for XtSetLanguageProc. */
14079 #else /* not USE_X_TOOLKIT */
14081 XSetLocaleModifiers ("");
14083 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
14084 #endif /* not USE_X_TOOLKIT */
14086 /* Detect failure. */
14093 /* We have definitely succeeded. Record the new connection. */
14095 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
14096 bzero (dpyinfo
, sizeof *dpyinfo
);
14098 #ifdef MULTI_KBOARD
14100 struct x_display_info
*share
;
14103 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
14104 share
= share
->next
, tail
= XCDR (tail
))
14105 if (same_x_server (XSTRING (XCAR (XCAR (tail
)))->data
,
14106 XSTRING (display_name
)->data
))
14109 dpyinfo
->kboard
= share
->kboard
;
14112 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
14113 init_kboard (dpyinfo
->kboard
);
14114 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
14116 char *vendor
= ServerVendor (dpy
);
14118 dpyinfo
->kboard
->Vsystem_key_alist
14119 = call1 (Qvendor_specific_keysyms
,
14120 build_string (vendor
? vendor
: ""));
14124 dpyinfo
->kboard
->next_kboard
= all_kboards
;
14125 all_kboards
= dpyinfo
->kboard
;
14126 /* Don't let the initial kboard remain current longer than necessary.
14127 That would cause problems if a file loaded on startup tries to
14128 prompt in the mini-buffer. */
14129 if (current_kboard
== initial_kboard
)
14130 current_kboard
= dpyinfo
->kboard
;
14132 dpyinfo
->kboard
->reference_count
++;
14136 /* Put this display on the chain. */
14137 dpyinfo
->next
= x_display_list
;
14138 x_display_list
= dpyinfo
;
14140 /* Put it on x_display_name_list as well, to keep them parallel. */
14141 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
14142 x_display_name_list
);
14143 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
14145 dpyinfo
->display
= dpy
;
14148 XSetAfterFunction (x_current_display
, x_trace_wire
);
14152 = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name
))
14153 + STRING_BYTES (XSTRING (Vsystem_name
))
14155 sprintf (dpyinfo
->x_id_name
, "%s@%s",
14156 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
14158 /* Figure out which modifier bits mean what. */
14159 x_find_modifier_meanings (dpyinfo
);
14161 /* Get the scroll bar cursor. */
14162 dpyinfo
->vertical_scroll_bar_cursor
14163 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
14165 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
14166 resource_name
, EMACS_CLASS
);
14167 #ifdef HAVE_XRMSETDATABASE
14168 XrmSetDatabase (dpyinfo
->display
, xrdb
);
14170 dpyinfo
->display
->db
= xrdb
;
14172 /* Put the rdb where we can find it in a way that works on
14174 dpyinfo
->xrdb
= xrdb
;
14176 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
14177 DefaultScreen (dpyinfo
->display
));
14178 select_visual (dpyinfo
);
14179 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
14180 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
14181 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
14182 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
14183 dpyinfo
->grabbed
= 0;
14184 dpyinfo
->reference_count
= 0;
14185 dpyinfo
->icon_bitmap_id
= -1;
14186 dpyinfo
->font_table
= NULL
;
14187 dpyinfo
->n_fonts
= 0;
14188 dpyinfo
->font_table_size
= 0;
14189 dpyinfo
->bitmaps
= 0;
14190 dpyinfo
->bitmaps_size
= 0;
14191 dpyinfo
->bitmaps_last
= 0;
14192 dpyinfo
->scratch_cursor_gc
= 0;
14193 dpyinfo
->mouse_face_mouse_frame
= 0;
14194 dpyinfo
->mouse_face_deferred_gc
= 0;
14195 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
14196 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
14197 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
14198 dpyinfo
->mouse_face_window
= Qnil
;
14199 dpyinfo
->mouse_face_overlay
= Qnil
;
14200 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
14201 dpyinfo
->mouse_face_defer
= 0;
14202 dpyinfo
->x_focus_frame
= 0;
14203 dpyinfo
->x_focus_event_frame
= 0;
14204 dpyinfo
->x_highlight_frame
= 0;
14205 dpyinfo
->image_cache
= make_image_cache ();
14207 /* See if a private colormap is requested. */
14208 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
14210 if (dpyinfo
->visual
->class == PseudoColor
)
14213 value
= display_x_get_resource (dpyinfo
,
14214 build_string ("privateColormap"),
14215 build_string ("PrivateColormap"),
14217 if (STRINGP (value
)
14218 && (!strcmp (XSTRING (value
)->data
, "true")
14219 || !strcmp (XSTRING (value
)->data
, "on")))
14220 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
14224 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
14225 dpyinfo
->visual
, AllocNone
);
14228 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
14229 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
14230 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
14231 dpyinfo
->resy
= pixels
* 25.4 / mm
;
14232 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
14233 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
14234 dpyinfo
->resx
= pixels
* 25.4 / mm
;
14237 dpyinfo
->Xatom_wm_protocols
14238 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
14239 dpyinfo
->Xatom_wm_take_focus
14240 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
14241 dpyinfo
->Xatom_wm_save_yourself
14242 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
14243 dpyinfo
->Xatom_wm_delete_window
14244 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
14245 dpyinfo
->Xatom_wm_change_state
14246 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
14247 dpyinfo
->Xatom_wm_configure_denied
14248 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
14249 dpyinfo
->Xatom_wm_window_moved
14250 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
14251 dpyinfo
->Xatom_editres
14252 = XInternAtom (dpyinfo
->display
, "Editres", False
);
14253 dpyinfo
->Xatom_CLIPBOARD
14254 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
14255 dpyinfo
->Xatom_TIMESTAMP
14256 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
14257 dpyinfo
->Xatom_TEXT
14258 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
14259 dpyinfo
->Xatom_COMPOUND_TEXT
14260 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
14261 dpyinfo
->Xatom_DELETE
14262 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
14263 dpyinfo
->Xatom_MULTIPLE
14264 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
14265 dpyinfo
->Xatom_INCR
14266 = XInternAtom (dpyinfo
->display
, "INCR", False
);
14267 dpyinfo
->Xatom_EMACS_TMP
14268 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
14269 dpyinfo
->Xatom_TARGETS
14270 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
14271 dpyinfo
->Xatom_NULL
14272 = XInternAtom (dpyinfo
->display
, "NULL", False
);
14273 dpyinfo
->Xatom_ATOM_PAIR
14274 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
14275 /* For properties of font. */
14276 dpyinfo
->Xatom_PIXEL_SIZE
14277 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
14278 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
14279 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
14280 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
14281 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
14282 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
14283 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
14285 /* Ghostscript support. */
14286 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
14287 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
14289 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
14292 dpyinfo
->cut_buffers_initialized
= 0;
14294 connection
= ConnectionNumber (dpyinfo
->display
);
14295 dpyinfo
->connection
= connection
;
14300 null_bits
[0] = 0x00;
14302 dpyinfo
->null_pixel
14303 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
14304 null_bits
, 1, 1, (long) 0, (long) 0,
14309 extern int gray_bitmap_width
, gray_bitmap_height
;
14310 extern char *gray_bitmap_bits
;
14312 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
14314 gray_bitmap_width
, gray_bitmap_height
,
14315 (unsigned long) 1, (unsigned long) 0, 1);
14319 xim_initialize (dpyinfo
, resource_name
);
14322 #ifdef subprocesses
14323 /* This is only needed for distinguishing keyboard and process input. */
14324 if (connection
!= 0)
14325 add_keyboard_wait_descriptor (connection
);
14328 #ifndef F_SETOWN_BUG
14330 #ifdef F_SETOWN_SOCK_NEG
14331 /* stdin is a socket here */
14332 fcntl (connection
, F_SETOWN
, -getpid ());
14333 #else /* ! defined (F_SETOWN_SOCK_NEG) */
14334 fcntl (connection
, F_SETOWN
, getpid ());
14335 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
14336 #endif /* ! defined (F_SETOWN) */
14337 #endif /* F_SETOWN_BUG */
14340 if (interrupt_input
)
14341 init_sigio (connection
);
14342 #endif /* ! defined (SIGIO) */
14345 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
14346 /* Make sure that we have a valid font for dialog boxes
14347 so that Xt does not crash. */
14349 Display
*dpy
= dpyinfo
->display
;
14350 XrmValue d
, fr
, to
;
14354 d
.addr
= (XPointer
)&dpy
;
14355 d
.size
= sizeof (Display
*);
14356 fr
.addr
= XtDefaultFont
;
14357 fr
.size
= sizeof (XtDefaultFont
);
14358 to
.size
= sizeof (Font
*);
14359 to
.addr
= (XPointer
)&font
;
14360 count
= x_catch_errors (dpy
);
14361 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
14363 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
14364 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
14365 x_uncatch_errors (dpy
, count
);
14370 /* See if we should run in synchronous mode. This is useful
14371 for debugging X code. */
14374 value
= display_x_get_resource (dpyinfo
,
14375 build_string ("synchronous"),
14376 build_string ("Synchronous"),
14378 if (STRINGP (value
)
14379 && (!strcmp (XSTRING (value
)->data
, "true")
14380 || !strcmp (XSTRING (value
)->data
, "on")))
14381 XSynchronize (dpyinfo
->display
, True
);
14389 /* Get rid of display DPYINFO, assuming all frames are already gone,
14390 and without sending any more commands to the X server. */
14393 x_delete_display (dpyinfo
)
14394 struct x_display_info
*dpyinfo
;
14396 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
14398 /* Discard this display from x_display_name_list and x_display_list.
14399 We can't use Fdelq because that can quit. */
14400 if (! NILP (x_display_name_list
)
14401 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
14402 x_display_name_list
= XCDR (x_display_name_list
);
14407 tail
= x_display_name_list
;
14408 while (CONSP (tail
) && CONSP (XCDR (tail
)))
14410 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
14412 XCDR (tail
) = XCDR (XCDR (tail
));
14415 tail
= XCDR (tail
);
14419 if (next_noop_dpyinfo
== dpyinfo
)
14420 next_noop_dpyinfo
= dpyinfo
->next
;
14422 if (x_display_list
== dpyinfo
)
14423 x_display_list
= dpyinfo
->next
;
14426 struct x_display_info
*tail
;
14428 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
14429 if (tail
->next
== dpyinfo
)
14430 tail
->next
= tail
->next
->next
;
14433 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
14434 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
14435 XrmDestroyDatabase (dpyinfo
->xrdb
);
14438 #ifdef MULTI_KBOARD
14439 if (--dpyinfo
->kboard
->reference_count
== 0)
14440 delete_kboard (dpyinfo
->kboard
);
14444 xim_close_dpy (dpyinfo
);
14447 xfree (dpyinfo
->font_table
);
14448 xfree (dpyinfo
->x_id_name
);
14449 xfree (dpyinfo
->color_cells
);
14454 /* Set up use of X before we make the first connection. */
14456 static struct redisplay_interface x_redisplay_interface
=
14461 x_clear_end_of_line
,
14463 x_after_update_window_line
,
14464 x_update_window_begin
,
14465 x_update_window_end
,
14468 x_clear_mouse_face
,
14469 x_get_glyph_overhangs
,
14470 x_fix_overlapping_area
14476 rif
= &x_redisplay_interface
;
14478 clear_frame_hook
= x_clear_frame
;
14479 ins_del_lines_hook
= x_ins_del_lines
;
14480 change_line_highlight_hook
= x_change_line_highlight
;
14481 delete_glyphs_hook
= x_delete_glyphs
;
14482 ring_bell_hook
= XTring_bell
;
14483 reset_terminal_modes_hook
= XTreset_terminal_modes
;
14484 set_terminal_modes_hook
= XTset_terminal_modes
;
14485 update_begin_hook
= x_update_begin
;
14486 update_end_hook
= x_update_end
;
14487 set_terminal_window_hook
= XTset_terminal_window
;
14488 read_socket_hook
= XTread_socket
;
14489 frame_up_to_date_hook
= XTframe_up_to_date
;
14490 reassert_line_highlight_hook
= XTreassert_line_highlight
;
14491 mouse_position_hook
= XTmouse_position
;
14492 frame_rehighlight_hook
= XTframe_rehighlight
;
14493 frame_raise_lower_hook
= XTframe_raise_lower
;
14494 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
14495 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
14496 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
14497 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
14498 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
14500 scroll_region_ok
= 1; /* we'll scroll partial frames */
14501 char_ins_del_ok
= 1;
14502 line_ins_del_ok
= 1; /* we'll just blt 'em */
14503 fast_clear_end_of_line
= 1; /* X does this well */
14504 memory_below_frame
= 0; /* we don't remember what scrolls
14509 last_tool_bar_item
= -1;
14510 any_help_event_p
= 0;
14512 /* Try to use interrupt input; if we can't, then start polling. */
14513 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
14515 #ifdef USE_X_TOOLKIT
14516 XtToolkitInitialize ();
14518 Xt_app_con
= XtCreateApplicationContext ();
14520 /* Register a converter from strings to pixels, which uses
14521 Emacs' color allocation infrastructure. */
14522 XtAppSetTypeConverter (Xt_app_con
,
14523 XtRString
, XtRPixel
, cvt_string_to_pixel
,
14524 cvt_string_to_pixel_args
,
14525 XtNumber (cvt_string_to_pixel_args
),
14526 XtCacheByDisplay
, cvt_pixel_dtor
);
14528 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
14530 /* Install an asynchronous timer that processes Xt timeout events
14531 every 0.1s. This is necessary because some widget sets use
14532 timeouts internally, for example the LessTif menu bar, or the
14533 Xaw3d scroll bar. When Xt timouts aren't processed, these
14534 widgets don't behave normally. */
14536 EMACS_TIME interval
;
14537 EMACS_SET_SECS_USECS (interval
, 0, 100000);
14538 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
14542 #ifdef USE_TOOLKIT_SCROLL_BARS
14543 xaw3d_arrow_scroll
= False
;
14544 xaw3d_pick_top
= True
;
14547 /* Note that there is no real way portable across R3/R4 to get the
14548 original error handler. */
14549 XSetErrorHandler (x_error_handler
);
14550 XSetIOErrorHandler (x_io_error_quitter
);
14552 /* Disable Window Change signals; they are handled by X events. */
14554 signal (SIGWINCH
, SIG_DFL
);
14555 #endif /* ! defined (SIGWINCH) */
14557 signal (SIGPIPE
, x_connection_signal
);
14564 staticpro (&x_error_message_string
);
14565 x_error_message_string
= Qnil
;
14567 staticpro (&x_display_name_list
);
14568 x_display_name_list
= Qnil
;
14570 staticpro (&last_mouse_scroll_bar
);
14571 last_mouse_scroll_bar
= Qnil
;
14573 staticpro (&Qvendor_specific_keysyms
);
14574 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
14576 staticpro (&last_mouse_press_frame
);
14577 last_mouse_press_frame
= Qnil
;
14580 staticpro (&help_echo
);
14581 help_echo_object
= Qnil
;
14582 staticpro (&help_echo_object
);
14583 help_echo_window
= Qnil
;
14584 staticpro (&help_echo_window
);
14585 previous_help_echo
= Qnil
;
14586 staticpro (&previous_help_echo
);
14587 help_echo_pos
= -1;
14589 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
14590 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
14591 For example, if a block cursor is over a tab, it will be drawn as\n\
14592 wide as that tab on the display.");
14593 x_stretch_cursor_p
= 0;
14595 DEFVAR_BOOL ("x-use-underline-position-properties",
14596 &x_use_underline_position_properties
,
14597 "*Non-nil means make use of UNDERLINE_POSITION font properties.\n\
14598 Nil means ignore them. If you encounter fonts with bogus\n\
14599 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior\n\
14600 to 4.1, set this to nil.");
14601 x_use_underline_position_properties
= 1;
14603 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
14604 "What X toolkit scroll bars Emacs uses.\n\
14605 A value of nil means Emacs doesn't use X toolkit scroll bars.\n\
14606 Otherwise, value is a symbol describing the X toolkit.");
14607 #ifdef USE_TOOLKIT_SCROLL_BARS
14609 Vx_toolkit_scroll_bars
= intern ("motif");
14610 #elif defined HAVE_XAW3D
14611 Vx_toolkit_scroll_bars
= intern ("xaw3d");
14613 Vx_toolkit_scroll_bars
= intern ("xaw");
14616 Vx_toolkit_scroll_bars
= Qnil
;
14619 staticpro (&last_mouse_motion_frame
);
14620 last_mouse_motion_frame
= Qnil
;
14623 #endif /* not HAVE_X_WINDOWS */