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 #include <Xm/ScrollBarP.h>
121 #else /* !USE_MOTIF i.e. use Xaw */
124 #include <X11/Xaw3d/Simple.h>
125 #include <X11/Xaw3d/Scrollbar.h>
126 #define ARROW_SCROLLBAR
127 #include <X11/Xaw3d/ScrollbarP.h>
128 #else /* !HAVE_XAW3D */
129 #include <X11/Xaw/Simple.h>
130 #include <X11/Xaw/Scrollbar.h>
131 #endif /* !HAVE_XAW3D */
133 #define XtNpickTop "pickTop"
134 #endif /* !XtNpickTop */
135 #endif /* !USE_MOTIF */
136 #endif /* USE_TOOLKIT_SCROLL_BARS */
138 #endif /* USE_X_TOOLKIT */
140 #ifndef USE_X_TOOLKIT
141 #define x_any_window_to_frame x_window_to_frame
142 #define x_top_window_to_frame x_window_to_frame
147 #ifndef XtNinitialState
148 #define XtNinitialState "initialState"
153 #define min(a,b) ((a) < (b) ? (a) : (b))
156 #define max(a,b) ((a) > (b) ? (a) : (b))
159 #define abs(x) ((x) < 0 ? -(x) : (x))
161 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
164 /* Bitmaps for truncated lines. */
169 LEFT_TRUNCATION_BITMAP
,
170 RIGHT_TRUNCATION_BITMAP
,
171 OVERLAY_ARROW_BITMAP
,
172 CONTINUED_LINE_BITMAP
,
173 CONTINUATION_LINE_BITMAP
,
177 /* Bitmap drawn to indicate lines not displaying text if
178 `indicate-empty-lines' is non-nil. */
182 static unsigned char zv_bits
[] = {
183 0x00, 0x00, 0x1e, 0x1e, 0x1e, 0x1e, 0x00, 0x00};
185 /* An arrow like this: `<-'. */
188 #define left_height 8
189 static unsigned char left_bits
[] = {
190 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
192 /* Right truncation arrow bitmap `->'. */
194 #define right_width 8
195 #define right_height 8
196 static unsigned char right_bits
[] = {
197 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
199 /* Marker for continued lines. */
201 #define continued_width 8
202 #define continued_height 8
203 static unsigned char continued_bits
[] = {
204 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
206 /* Marker for continuation lines. */
208 #define continuation_width 8
209 #define continuation_height 8
210 static unsigned char continuation_bits
[] = {
211 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
213 /* Overlay arrow bitmap. */
219 static unsigned char ov_bits
[] = {
220 0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
222 /* A triangular arrow. */
225 static unsigned char ov_bits
[] = {
226 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
230 extern Lisp_Object Qhelp_echo
;
233 /* Non-nil means Emacs uses toolkit scroll bars. */
235 Lisp_Object Vx_toolkit_scroll_bars
;
237 /* If a string, XTread_socket generates an event to display that string.
238 (The display is done in read_char.) */
240 static Lisp_Object help_echo
;
241 static Lisp_Object help_echo_window
;
242 static Lisp_Object help_echo_object
;
243 static int help_echo_pos
;
245 /* Temporary variable for XTread_socket. */
247 static Lisp_Object previous_help_echo
;
249 /* Non-zero means that a HELP_EVENT has been generated since Emacs
252 static int any_help_event_p
;
254 /* Non-zero means draw block and hollow cursor as wide as the glyph
255 under it. For example, if a block cursor is over a tab, it will be
256 drawn as wide as that tab on the display. */
258 int x_stretch_cursor_p
;
260 /* This is a chain of structures for all the X displays currently in
263 struct x_display_info
*x_display_list
;
265 /* This is a list of cons cells, each of the form (NAME
266 . FONT-LIST-CACHE), one for each element of x_display_list and in
267 the same order. NAME is the name of the frame. FONT-LIST-CACHE
268 records previous values returned by x-list-fonts. */
270 Lisp_Object x_display_name_list
;
272 /* Frame being updated by update_frame. This is declared in term.c.
273 This is set by update_begin and looked at by all the XT functions.
274 It is zero while not inside an update. In that case, the XT
275 functions assume that `selected_frame' is the frame to apply to. */
277 extern struct frame
*updating_frame
;
279 extern int waiting_for_input
;
281 /* This is a frame waiting to be auto-raised, within XTread_socket. */
283 struct frame
*pending_autoraise_frame
;
286 /* The application context for Xt use. */
287 XtAppContext Xt_app_con
;
288 static String Xt_default_resources
[] = {0};
289 #endif /* USE_X_TOOLKIT */
291 /* Nominal cursor position -- where to draw output.
292 HPOS and VPOS are window relative glyph matrix coordinates.
293 X and Y are window relative pixel coordinates. */
295 struct cursor_pos output_cursor
;
297 /* Non-zero means user is interacting with a toolkit scroll bar. */
299 static int toolkit_scroll_bar_interaction
;
303 Formerly, we used PointerMotionHintMask (in standard_event_mask)
304 so that we would have to call XQueryPointer after each MotionNotify
305 event to ask for another such event. However, this made mouse tracking
306 slow, and there was a bug that made it eventually stop.
308 Simply asking for MotionNotify all the time seems to work better.
310 In order to avoid asking for motion events and then throwing most
311 of them away or busy-polling the server for mouse positions, we ask
312 the server for pointer motion hints. This means that we get only
313 one event per group of mouse movements. "Groups" are delimited by
314 other kinds of events (focus changes and button clicks, for
315 example), or by XQueryPointer calls; when one of these happens, we
316 get another MotionNotify event the next time the mouse moves. This
317 is at least as efficient as getting motion events when mouse
318 tracking is on, and I suspect only negligibly worse when tracking
321 /* Where the mouse was last time we reported a mouse event. */
323 FRAME_PTR last_mouse_frame
;
324 static XRectangle last_mouse_glyph
;
325 static Lisp_Object last_mouse_press_frame
;
327 /* The scroll bar in which the last X motion event occurred.
329 If the last X motion event occurred in a scroll bar, we set this so
330 XTmouse_position can know whether to report a scroll bar motion or
333 If the last X motion event didn't occur in a scroll bar, we set
334 this to Qnil, to tell XTmouse_position to return an ordinary motion
337 static Lisp_Object last_mouse_scroll_bar
;
339 /* This is a hack. We would really prefer that XTmouse_position would
340 return the time associated with the position it returns, but there
341 doesn't seem to be any way to wrest the time-stamp from the server
342 along with the position query. So, we just keep track of the time
343 of the last movement we received, and return that in hopes that
344 it's somewhat accurate. */
346 static Time last_mouse_movement_time
;
348 /* Incremented by XTread_socket whenever it really tries to read
352 static int volatile input_signal_count
;
354 static int input_signal_count
;
357 /* Used locally within XTread_socket. */
359 static int x_noop_count
;
361 /* Initial values of argv and argc. */
363 extern char **initial_argv
;
364 extern int initial_argc
;
366 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
368 /* Tells if a window manager is present or not. */
370 extern Lisp_Object Vx_no_window_manager
;
372 extern Lisp_Object Qface
, Qmouse_face
;
376 /* A mask of extra modifier bits to put into every keyboard char. */
378 extern int extra_keyboard_modifiers
;
380 static Lisp_Object Qvendor_specific_keysyms
;
382 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
383 extern Lisp_Object x_icon_type
P_ ((struct frame
*));
386 /* Enumeration for overriding/changing the face to use for drawing
387 glyphs in x_draw_glyphs. */
389 enum draw_glyphs_face
399 static void x_set_window_size_1
P_ ((struct frame
*, int, int, int));
400 static const XColor
*x_color_cells
P_ ((struct frame
*, int *));
401 static void x_update_window_end
P_ ((struct window
*, int, int));
402 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
403 void x_delete_display
P_ ((struct x_display_info
*));
404 static unsigned int x_x_to_emacs_modifiers
P_ ((struct x_display_info
*,
406 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
408 static void set_output_cursor
P_ ((struct cursor_pos
*));
409 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
410 int *, int *, int *));
411 static void note_mode_line_highlight
P_ ((struct window
*, int, int));
412 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
413 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
414 static void x_handle_tool_bar_click
P_ ((struct frame
*, XButtonEvent
*));
415 static void show_mouse_face
P_ ((struct x_display_info
*,
416 enum draw_glyphs_face
));
417 static int x_io_error_quitter
P_ ((Display
*));
418 int x_catch_errors
P_ ((Display
*));
419 void x_uncatch_errors
P_ ((Display
*, int));
420 void x_lower_frame
P_ ((struct frame
*));
421 void x_scroll_bar_clear
P_ ((struct frame
*));
422 int x_had_errors_p
P_ ((Display
*));
423 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
424 void x_raise_frame
P_ ((struct frame
*));
425 void x_set_window_size
P_ ((struct frame
*, int, int, int));
426 void x_wm_set_window_state
P_ ((struct frame
*, int));
427 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
428 void x_initialize
P_ ((void));
429 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
430 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
431 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
433 enum draw_glyphs_face
));
434 static void x_update_end
P_ ((struct frame
*));
435 static void XTframe_up_to_date
P_ ((struct frame
*));
436 static void XTreassert_line_highlight
P_ ((int, int));
437 static void x_change_line_highlight
P_ ((int, int, int, int));
438 static void XTset_terminal_modes
P_ ((void));
439 static void XTreset_terminal_modes
P_ ((void));
440 static void XTcursor_to
P_ ((int, int, int, int));
441 static void x_write_glyphs
P_ ((struct glyph
*, int));
442 static void x_clear_end_of_line
P_ ((int));
443 static void x_clear_frame
P_ ((void));
444 static void x_clear_cursor
P_ ((struct window
*));
445 static void frame_highlight
P_ ((struct frame
*));
446 static void frame_unhighlight
P_ ((struct frame
*));
447 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
448 static void XTframe_rehighlight
P_ ((struct frame
*));
449 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
450 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
451 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int));
452 static int x_intersect_rectangles
P_ ((XRectangle
*, XRectangle
*,
454 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
455 static void expose_window_tree
P_ ((struct window
*, XRectangle
*));
456 static void expose_window
P_ ((struct window
*, XRectangle
*));
457 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
458 XRectangle
*, enum glyph_row_area
));
459 static void expose_line
P_ ((struct window
*, struct glyph_row
*,
461 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
462 static void x_update_window_cursor
P_ ((struct window
*, int));
463 static void x_erase_phys_cursor
P_ ((struct window
*));
464 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
465 static void x_draw_bitmap
P_ ((struct window
*, struct glyph_row
*,
468 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
470 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, XRectangle
*));
471 static void x_draw_row_bitmaps
P_ ((struct window
*, struct glyph_row
*));
472 static void note_overwritten_text_cursor
P_ ((struct window
*, int, int));
473 static void x_flush
P_ ((struct frame
*f
));
474 static void x_update_begin
P_ ((struct frame
*));
475 static void x_update_window_begin
P_ ((struct window
*));
476 static void x_draw_vertical_border
P_ ((struct window
*));
477 static void x_after_update_window_line
P_ ((struct glyph_row
*));
478 static INLINE
void take_vertical_position_into_account
P_ ((struct it
*));
479 static void x_produce_stretch_glyph
P_ ((struct it
*));
482 /* Flush display of frame F, or of all frames if F is null. */
491 Lisp_Object rest
, frame
;
492 FOR_EACH_FRAME (rest
, frame
)
493 x_flush (XFRAME (frame
));
495 else if (FRAME_X_P (f
))
496 XFlush (FRAME_X_DISPLAY (f
));
501 /* Remove calls to XFlush by defining XFlush to an empty replacement.
502 Calls to XFlush should be unnecessary because the X output buffer
503 is flushed automatically as needed by calls to XPending,
504 XNextEvent, or XWindowEvent according to the XFlush man page.
505 XTread_socket calls XPending. Removing XFlush improves
508 #define XFlush(DISPLAY) (void) 0
511 /***********************************************************************
513 ***********************************************************************/
517 /* This is a function useful for recording debugging information about
518 the sequence of occurrences in this file. */
526 struct record event_record
[100];
528 int event_record_index
;
530 record_event (locus
, type
)
534 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
535 event_record_index
= 0;
537 event_record
[event_record_index
].locus
= locus
;
538 event_record
[event_record_index
].type
= type
;
539 event_record_index
++;
546 /* Return the struct x_display_info corresponding to DPY. */
548 struct x_display_info
*
549 x_display_info_for_display (dpy
)
552 struct x_display_info
*dpyinfo
;
554 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
555 if (dpyinfo
->display
== dpy
)
563 /***********************************************************************
564 Starting and ending an update
565 ***********************************************************************/
567 /* Start an update of frame F. This function is installed as a hook
568 for update_begin, i.e. it is called when update_begin is called.
569 This function is called prior to calls to x_update_window_begin for
570 each window being updated. Currently, there is nothing to do here
571 because all interesting stuff is done on a window basis. */
581 /* Start update of window W. Set the global variable updated_window
582 to the window being updated and set output_cursor to the cursor
586 x_update_window_begin (w
)
589 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
590 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
593 set_output_cursor (&w
->cursor
);
597 if (f
== display_info
->mouse_face_mouse_frame
)
599 /* Don't do highlighting for mouse motion during the update. */
600 display_info
->mouse_face_defer
= 1;
602 /* If F needs to be redrawn, simply forget about any prior mouse
604 if (FRAME_GARBAGED_P (f
))
605 display_info
->mouse_face_window
= Qnil
;
607 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
608 their mouse_face_p flag set, which means that they are always
609 unequal to rows in a desired matrix which never have that
610 flag set. So, rows containing mouse-face glyphs are never
611 scrolled, and we don't have to switch the mouse highlight off
612 here to prevent it from being scrolled. */
614 /* Can we tell that this update does not affect the window
615 where the mouse highlight is? If so, no need to turn off.
616 Likewise, don't do anything if the frame is garbaged;
617 in that case, the frame's current matrix that we would use
618 is all wrong, and we will redisplay that line anyway. */
619 if (!NILP (display_info
->mouse_face_window
)
620 && w
== XWINDOW (display_info
->mouse_face_window
))
624 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
625 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
628 if (i
< w
->desired_matrix
->nrows
)
629 clear_mouse_face (display_info
);
638 /* Draw a vertical window border to the right of window W if W doesn't
639 have vertical scroll bars. */
642 x_draw_vertical_border (w
)
645 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
647 /* Redraw borders between horizontally adjacent windows. Don't
648 do it for frames with vertical scroll bars because either the
649 right scroll bar of a window, or the left scroll bar of its
650 neighbor will suffice as a border. */
651 if (!WINDOW_RIGHTMOST_P (w
)
652 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
656 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
657 x1
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
);
660 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
661 f
->output_data
.x
->normal_gc
, x1
, y0
, x1
, y1
);
666 /* End update of window W (which is equal to updated_window).
668 Draw vertical borders between horizontally adjacent windows, and
669 display W's cursor if CURSOR_ON_P is non-zero.
671 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
672 glyphs in mouse-face were overwritten. In that case we have to
673 make sure that the mouse-highlight is properly redrawn.
675 W may be a menu bar pseudo-window in case we don't have X toolkit
676 support. Such windows don't have a cursor, so don't display it
680 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
682 int cursor_on_p
, mouse_face_overwritten_p
;
684 if (!w
->pseudo_window_p
)
686 struct x_display_info
*dpyinfo
687 = FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
691 /* If a row with mouse-face was overwritten, arrange for
692 XTframe_up_to_date to redisplay the mouse highlight. */
693 if (mouse_face_overwritten_p
)
695 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
696 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
697 dpyinfo
->mouse_face_window
= Qnil
;
701 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
703 output_cursor
.x
, output_cursor
.y
);
705 x_draw_vertical_border (w
);
709 updated_window
= NULL
;
713 /* End update of frame F. This function is installed as a hook in
720 /* Mouse highlight may be displayed again. */
721 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
724 XFlush (FRAME_X_DISPLAY (f
));
729 /* This function is called from various places in xdisp.c whenever a
730 complete update has been performed. The global variable
731 updated_window is not available here. */
734 XTframe_up_to_date (f
)
739 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
741 if (dpyinfo
->mouse_face_deferred_gc
742 || f
== dpyinfo
->mouse_face_mouse_frame
)
745 if (dpyinfo
->mouse_face_mouse_frame
)
746 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
747 dpyinfo
->mouse_face_mouse_x
,
748 dpyinfo
->mouse_face_mouse_y
);
749 dpyinfo
->mouse_face_deferred_gc
= 0;
756 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
757 arrow bitmaps, or clear the areas where they would be displayed
758 before DESIRED_ROW is made current. The window being updated is
759 found in updated_window. This function It is called from
760 update_window_line only if it is known that there are differences
761 between bitmaps to be drawn between current row and DESIRED_ROW. */
764 x_after_update_window_line (desired_row
)
765 struct glyph_row
*desired_row
;
767 struct window
*w
= updated_window
;
771 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
777 x_draw_row_bitmaps (w
, desired_row
);
779 /* When a window has disappeared, make sure that no rest of
780 full-width rows stays visible in the internal border. */
781 if (windows_or_buffers_changed
782 && (f
= XFRAME (w
->frame
),
783 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
786 int height
= desired_row
->visible_height
;
787 int x
= (window_box_right (w
, -1)
788 + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
));
789 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
791 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
792 x
, y
, width
, height
, False
);
800 /* Draw the bitmap WHICH in one of the areas to the left or right of
801 window W. ROW is the glyph row for which to display the bitmap; it
802 determines the vertical position at which the bitmap has to be
806 x_draw_bitmap (w
, row
, which
)
808 struct glyph_row
*row
;
809 enum bitmap_type which
;
811 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
812 Display
*display
= FRAME_X_DISPLAY (f
);
813 Window window
= FRAME_X_WINDOW (f
);
817 GC gc
= f
->output_data
.x
->normal_gc
;
819 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
821 /* Must clip because of partially visible lines. */
822 x_clip_to_row (w
, row
, gc
, 1);
826 case LEFT_TRUNCATION_BITMAP
:
830 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
832 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
835 case OVERLAY_ARROW_BITMAP
:
839 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
841 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
844 case RIGHT_TRUNCATION_BITMAP
:
848 x
= window_box_right (w
, -1);
849 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
852 case CONTINUED_LINE_BITMAP
:
855 bits
= continued_bits
;
856 x
= window_box_right (w
, -1);
857 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
860 case CONTINUATION_LINE_BITMAP
:
861 wd
= continuation_width
;
862 h
= continuation_height
;
863 bits
= continuation_bits
;
864 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
866 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
873 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
875 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
882 /* Convert to frame coordinates. Set dy to the offset in the row to
883 start drawing the bitmap. */
884 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
885 dy
= (row
->height
- h
) / 2;
887 /* Draw the bitmap. I believe these small pixmaps can be cached
889 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
890 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, wd
, h
,
892 face
->background
, depth
);
893 XCopyArea (display
, pixmap
, window
, gc
, 0, 0, wd
, h
, x
, y
+ dy
);
894 XFreePixmap (display
, pixmap
);
895 XSetClipMask (display
, gc
, None
);
899 /* Draw flags bitmaps for glyph row ROW on window W. Call this
900 function with input blocked. */
903 x_draw_row_bitmaps (w
, row
)
905 struct glyph_row
*row
;
907 struct frame
*f
= XFRAME (w
->frame
);
908 enum bitmap_type bitmap
;
910 int header_line_height
= -1;
912 xassert (interrupt_input_blocked
);
914 /* If row is completely invisible, because of vscrolling, we
915 don't have to draw anything. */
916 if (row
->visible_height
<= 0)
919 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
920 PREPARE_FACE_FOR_DISPLAY (f
, face
);
922 /* Decide which bitmap to draw at the left side. */
923 if (row
->overlay_arrow_p
)
924 bitmap
= OVERLAY_ARROW_BITMAP
;
925 else if (row
->truncated_on_left_p
)
926 bitmap
= LEFT_TRUNCATION_BITMAP
;
927 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
928 bitmap
= CONTINUATION_LINE_BITMAP
;
929 else if (row
->indicate_empty_line_p
)
930 bitmap
= ZV_LINE_BITMAP
;
934 /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
936 if (bitmap
== NO_BITMAP
937 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
938 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
940 /* If W has a vertical border to its left, don't draw over it. */
941 int border
= ((XFASTINT (w
->left
) > 0
942 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
944 int left
= window_box_left (w
, -1);
946 if (header_line_height
< 0)
947 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
949 /* In case the same realized face is used for bitmap areas and
950 for something displayed in the text (e.g. face `region' on
951 mono-displays, the fill style may have been changed to
952 FillSolid in x_draw_glyph_string_background. */
954 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
956 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
958 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
961 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
963 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
965 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - border
,
966 row
->visible_height
);
968 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
971 /* Draw the left bitmap. */
972 if (bitmap
!= NO_BITMAP
)
973 x_draw_bitmap (w
, row
, bitmap
);
975 /* Decide which bitmap to draw at the right side. */
976 if (row
->truncated_on_right_p
)
977 bitmap
= RIGHT_TRUNCATION_BITMAP
;
978 else if (row
->continued_p
)
979 bitmap
= CONTINUED_LINE_BITMAP
;
983 /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
985 if (bitmap
== NO_BITMAP
986 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
)
987 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
989 int right
= window_box_right (w
, -1);
991 if (header_line_height
< 0)
992 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
994 /* In case the same realized face is used for bitmap areas and
995 for something displayed in the text (e.g. face `region' on
996 mono-displays, the fill style may have been changed to
997 FillSolid in x_draw_glyph_string_background. */
999 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
1001 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
1002 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1005 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
1007 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
),
1008 row
->visible_height
);
1010 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
1013 /* Draw the right bitmap. */
1014 if (bitmap
!= NO_BITMAP
)
1015 x_draw_bitmap (w
, row
, bitmap
);
1019 /***********************************************************************
1021 ***********************************************************************/
1023 /* External interface to control of standout mode. Not used for X
1024 frames. Aborts when called. */
1027 XTreassert_line_highlight (new, vpos
)
1034 /* Call this when about to modify line at position VPOS and change
1035 whether it is highlighted. Not used for X frames. Aborts when
1039 x_change_line_highlight (new_highlight
, vpos
, y
, first_unused_hpos
)
1040 int new_highlight
, vpos
, y
, first_unused_hpos
;
1046 /* This is called when starting Emacs and when restarting after
1047 suspend. When starting Emacs, no X window is mapped. And nothing
1048 must be done to Emacs's own window if it is suspended (though that
1052 XTset_terminal_modes ()
1056 /* This is called when exiting or suspending Emacs. Exiting will make
1057 the X-windows go away, and suspending requires no action. */
1060 XTreset_terminal_modes ()
1066 /***********************************************************************
1068 ***********************************************************************/
1070 /* Set the global variable output_cursor to CURSOR. All cursor
1071 positions are relative to updated_window. */
1074 set_output_cursor (cursor
)
1075 struct cursor_pos
*cursor
;
1077 output_cursor
.hpos
= cursor
->hpos
;
1078 output_cursor
.vpos
= cursor
->vpos
;
1079 output_cursor
.x
= cursor
->x
;
1080 output_cursor
.y
= cursor
->y
;
1084 /* Set a nominal cursor position.
1086 HPOS and VPOS are column/row positions in a window glyph matrix. X
1087 and Y are window text area relative pixel positions.
1089 If this is done during an update, updated_window will contain the
1090 window that is being updated and the position is the future output
1091 cursor position for that window. If updated_window is null, use
1092 selected_window and display the cursor at the given position. */
1095 XTcursor_to (vpos
, hpos
, y
, x
)
1096 int vpos
, hpos
, y
, x
;
1100 /* If updated_window is not set, work on selected_window. */
1104 w
= XWINDOW (selected_window
);
1106 /* Set the output cursor. */
1107 output_cursor
.hpos
= hpos
;
1108 output_cursor
.vpos
= vpos
;
1109 output_cursor
.x
= x
;
1110 output_cursor
.y
= y
;
1112 /* If not called as part of an update, really display the cursor.
1113 This will also set the cursor position of W. */
1114 if (updated_window
== NULL
)
1117 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1118 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1125 /***********************************************************************
1127 ***********************************************************************/
1129 /* Function prototypes of this page. */
1131 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1135 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1136 int, XChar2b
*, int));
1137 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
1138 static void x_encode_char
P_ ((int, XChar2b
*, struct font_info
*));
1139 static void x_append_glyph
P_ ((struct it
*));
1140 static void x_append_composite_glyph
P_ ((struct it
*));
1141 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1143 static void x_produce_glyphs
P_ ((struct it
*));
1144 static void x_produce_image_glyph
P_ ((struct it
*it
));
1147 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1148 is not contained in the font. */
1150 static INLINE XCharStruct
*
1151 x_per_char_metric (font
, char2b
)
1155 /* The result metric information. */
1156 XCharStruct
*pcm
= NULL
;
1158 xassert (font
&& char2b
);
1160 if (font
->per_char
!= NULL
)
1162 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
1164 /* min_char_or_byte2 specifies the linear character index
1165 corresponding to the first element of the per_char array,
1166 max_char_or_byte2 is the index of the last character. A
1167 character with non-zero CHAR2B->byte1 is not in the font.
1168 A character with byte2 less than min_char_or_byte2 or
1169 greater max_char_or_byte2 is not in the font. */
1170 if (char2b
->byte1
== 0
1171 && char2b
->byte2
>= font
->min_char_or_byte2
1172 && char2b
->byte2
<= font
->max_char_or_byte2
)
1173 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
1177 /* If either min_byte1 or max_byte1 are nonzero, both
1178 min_char_or_byte2 and max_char_or_byte2 are less than
1179 256, and the 2-byte character index values corresponding
1180 to the per_char array element N (counting from 0) are:
1182 byte1 = N/D + min_byte1
1183 byte2 = N\D + min_char_or_byte2
1187 D = max_char_or_byte2 - min_char_or_byte2 + 1
1188 / = integer division
1189 \ = integer modulus */
1190 if (char2b
->byte1
>= font
->min_byte1
1191 && char2b
->byte1
<= font
->max_byte1
1192 && char2b
->byte2
>= font
->min_char_or_byte2
1193 && char2b
->byte2
<= font
->max_char_or_byte2
)
1195 pcm
= (font
->per_char
1196 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
1197 * (char2b
->byte1
- font
->min_byte1
))
1198 + (char2b
->byte2
- font
->min_char_or_byte2
));
1204 /* If the per_char pointer is null, all glyphs between the first
1205 and last character indexes inclusive have the same
1206 information, as given by both min_bounds and max_bounds. */
1207 if (char2b
->byte2
>= font
->min_char_or_byte2
1208 && char2b
->byte2
<= font
->max_char_or_byte2
)
1209 pcm
= &font
->max_bounds
;
1212 return ((pcm
== NULL
1213 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
1218 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1219 the two-byte form of C. Encoding is returned in *CHAR2B. */
1222 x_encode_char (c
, char2b
, font_info
)
1225 struct font_info
*font_info
;
1227 int charset
= CHAR_CHARSET (c
);
1228 XFontStruct
*font
= font_info
->font
;
1230 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1231 This may be either a program in a special encoder language or a
1233 if (font_info
->font_encoder
)
1235 /* It's a program. */
1236 struct ccl_program
*ccl
= font_info
->font_encoder
;
1238 if (CHARSET_DIMENSION (charset
) == 1)
1240 ccl
->reg
[0] = charset
;
1241 ccl
->reg
[1] = char2b
->byte2
;
1245 ccl
->reg
[0] = charset
;
1246 ccl
->reg
[1] = char2b
->byte1
;
1247 ccl
->reg
[2] = char2b
->byte2
;
1250 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1252 /* We assume that MSBs are appropriately set/reset by CCL
1254 if (font
->max_byte1
== 0) /* 1-byte font */
1255 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
1257 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
1259 else if (font_info
->encoding
[charset
])
1261 /* Fixed encoding scheme. See fontset.h for the meaning of the
1262 encoding numbers. */
1263 int enc
= font_info
->encoding
[charset
];
1265 if ((enc
== 1 || enc
== 2)
1266 && CHARSET_DIMENSION (charset
) == 2)
1267 char2b
->byte1
|= 0x80;
1269 if (enc
== 1 || enc
== 3)
1270 char2b
->byte2
|= 0x80;
1275 /* Get face and two-byte form of character C in face FACE_ID on frame
1276 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1277 means we want to display multibyte text. Value is a pointer to a
1278 realized face that is ready for display. */
1280 static INLINE
struct face
*
1281 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
)
1287 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1291 /* Unibyte case. We don't have to encode, but we have to make
1292 sure to use a face suitable for unibyte. */
1295 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1296 face
= FACE_FROM_ID (f
, face_id
);
1298 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1300 /* Case of ASCII in a face known to fit ASCII. */
1306 int c1
, c2
, charset
;
1308 /* Split characters into bytes. If c2 is -1 afterwards, C is
1309 really a one-byte character so that byte1 is zero. */
1310 SPLIT_CHAR (c
, charset
, c1
, c2
);
1312 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1314 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1316 /* Maybe encode the character in *CHAR2B. */
1317 if (face
->font
!= NULL
)
1319 struct font_info
*font_info
1320 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1322 x_encode_char (c
, char2b
, font_info
);
1326 /* Make sure X resources of the face are allocated. */
1327 xassert (face
!= NULL
);
1328 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1334 /* Get face and two-byte form of character glyph GLYPH on frame F.
1335 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1336 a pointer to a realized face that is ready for display. */
1338 static INLINE
struct face
*
1339 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1341 struct glyph
*glyph
;
1347 xassert (glyph
->type
== CHAR_GLYPH
);
1348 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1353 if (!glyph
->multibyte_p
)
1355 /* Unibyte case. We don't have to encode, but we have to make
1356 sure to use a face suitable for unibyte. */
1358 char2b
->byte2
= glyph
->u
.ch
;
1360 else if (glyph
->u
.ch
< 128
1361 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1363 /* Case of ASCII in a face known to fit ASCII. */
1365 char2b
->byte2
= glyph
->u
.ch
;
1369 int c1
, c2
, charset
;
1371 /* Split characters into bytes. If c2 is -1 afterwards, C is
1372 really a one-byte character so that byte1 is zero. */
1373 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1375 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1377 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1379 /* Maybe encode the character in *CHAR2B. */
1380 if (charset
!= CHARSET_ASCII
)
1382 struct font_info
*font_info
1383 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1386 x_encode_char (glyph
->u
.ch
, char2b
, font_info
);
1389 = ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
1394 /* Make sure X resources of the face are allocated. */
1395 xassert (face
!= NULL
);
1396 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1401 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1402 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1408 struct glyph
*glyph
;
1409 enum glyph_row_area area
= it
->area
;
1411 xassert (it
->glyph_row
);
1412 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1414 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1415 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1417 glyph
->charpos
= CHARPOS (it
->position
);
1418 glyph
->object
= it
->object
;
1419 glyph
->pixel_width
= it
->pixel_width
;
1420 glyph
->voffset
= it
->voffset
;
1421 glyph
->type
= CHAR_GLYPH
;
1422 glyph
->multibyte_p
= it
->multibyte_p
;
1423 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1424 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1425 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1426 || it
->phys_descent
> it
->descent
);
1427 glyph
->padding_p
= 0;
1428 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1429 glyph
->face_id
= it
->face_id
;
1430 glyph
->u
.ch
= it
->char_to_display
;
1431 ++it
->glyph_row
->used
[area
];
1435 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1436 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1439 x_append_composite_glyph (it
)
1442 struct glyph
*glyph
;
1443 enum glyph_row_area area
= it
->area
;
1445 xassert (it
->glyph_row
);
1447 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1448 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1450 glyph
->charpos
= CHARPOS (it
->position
);
1451 glyph
->object
= it
->object
;
1452 glyph
->pixel_width
= it
->pixel_width
;
1453 glyph
->voffset
= it
->voffset
;
1454 glyph
->type
= COMPOSITE_GLYPH
;
1455 glyph
->multibyte_p
= it
->multibyte_p
;
1456 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1457 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1458 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1459 || it
->phys_descent
> it
->descent
);
1460 glyph
->padding_p
= 0;
1461 glyph
->glyph_not_available_p
= 0;
1462 glyph
->face_id
= it
->face_id
;
1463 glyph
->u
.cmp_id
= it
->cmp_id
;
1464 ++it
->glyph_row
->used
[area
];
1469 /* Change IT->ascent and IT->height according to the setting of
1473 take_vertical_position_into_account (it
)
1478 if (it
->voffset
< 0)
1479 /* Increase the ascent so that we can display the text higher
1481 it
->ascent
+= abs (it
->voffset
);
1483 /* Increase the descent so that we can display the text lower
1485 it
->descent
+= it
->voffset
;
1490 /* Produce glyphs/get display metrics for the image IT is loaded with.
1491 See the description of struct display_iterator in dispextern.h for
1492 an overview of struct display_iterator. */
1495 x_produce_image_glyph (it
)
1501 xassert (it
->what
== IT_IMAGE
);
1503 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1504 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1507 /* Make sure X resources of the face and image are loaded. */
1508 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1509 prepare_image_for_display (it
->f
, img
);
1511 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1512 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->vmargin
- it
->ascent
;
1513 it
->pixel_width
= img
->width
+ 2 * img
->hmargin
;
1517 if (face
->box
!= FACE_NO_BOX
)
1519 if (face
->box_line_width
> 0)
1521 it
->ascent
+= face
->box_line_width
;
1522 it
->descent
+= face
->box_line_width
;
1525 if (it
->start_of_box_run_p
)
1526 it
->pixel_width
+= abs (face
->box_line_width
);
1527 if (it
->end_of_box_run_p
)
1528 it
->pixel_width
+= abs (face
->box_line_width
);
1531 take_vertical_position_into_account (it
);
1535 struct glyph
*glyph
;
1536 enum glyph_row_area area
= it
->area
;
1538 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1539 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1541 glyph
->charpos
= CHARPOS (it
->position
);
1542 glyph
->object
= it
->object
;
1543 glyph
->pixel_width
= it
->pixel_width
;
1544 glyph
->voffset
= it
->voffset
;
1545 glyph
->type
= IMAGE_GLYPH
;
1546 glyph
->multibyte_p
= it
->multibyte_p
;
1547 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1548 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1549 glyph
->overlaps_vertically_p
= 0;
1550 glyph
->padding_p
= 0;
1551 glyph
->glyph_not_available_p
= 0;
1552 glyph
->face_id
= it
->face_id
;
1553 glyph
->u
.img_id
= img
->id
;
1554 ++it
->glyph_row
->used
[area
];
1560 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1561 of the glyph, WIDTH and HEIGHT are the width and height of the
1562 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1563 ascent of the glyph (0 <= ASCENT <= 1). */
1566 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1572 struct glyph
*glyph
;
1573 enum glyph_row_area area
= it
->area
;
1575 xassert (ascent
>= 0 && ascent
<= 1);
1577 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1578 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1580 glyph
->charpos
= CHARPOS (it
->position
);
1581 glyph
->object
= object
;
1582 glyph
->pixel_width
= width
;
1583 glyph
->voffset
= it
->voffset
;
1584 glyph
->type
= STRETCH_GLYPH
;
1585 glyph
->multibyte_p
= it
->multibyte_p
;
1586 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1587 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1588 glyph
->overlaps_vertically_p
= 0;
1589 glyph
->padding_p
= 0;
1590 glyph
->glyph_not_available_p
= 0;
1591 glyph
->face_id
= it
->face_id
;
1592 glyph
->u
.stretch
.ascent
= height
* ascent
;
1593 glyph
->u
.stretch
.height
= height
;
1594 ++it
->glyph_row
->used
[area
];
1599 /* Produce a stretch glyph for iterator IT. IT->object is the value
1600 of the glyph property displayed. The value must be a list
1601 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1604 1. `:width WIDTH' specifies that the space should be WIDTH *
1605 canonical char width wide. WIDTH may be an integer or floating
1608 2. `:relative-width FACTOR' specifies that the width of the stretch
1609 should be computed from the width of the first character having the
1610 `glyph' property, and should be FACTOR times that width.
1612 3. `:align-to HPOS' specifies that the space should be wide enough
1613 to reach HPOS, a value in canonical character units.
1615 Exactly one of the above pairs must be present.
1617 4. `:height HEIGHT' specifies that the height of the stretch produced
1618 should be HEIGHT, measured in canonical character units.
1620 5. `:relative-height FACTOR' specifies that the height of the the
1621 stretch should be FACTOR times the height of the characters having
1624 Either none or exactly one of 4 or 5 must be present.
1626 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1627 of the stretch should be used for the ascent of the stretch.
1628 ASCENT must be in the range 0 <= ASCENT <= 100. */
1631 ((INTEGERP (X) || FLOATP (X)) \
1637 x_produce_stretch_glyph (it
)
1640 /* (space :width WIDTH :height HEIGHT. */
1642 extern Lisp_Object Qspace
;
1644 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
1645 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1646 extern Lisp_Object QCalign_to
;
1647 Lisp_Object prop
, plist
;
1648 double width
= 0, height
= 0, ascent
= 0;
1649 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1650 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1652 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1654 /* List should start with `space'. */
1655 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1656 plist
= XCDR (it
->object
);
1658 /* Compute the width of the stretch. */
1659 if (prop
= Fplist_get (plist
, QCwidth
),
1661 /* Absolute width `:width WIDTH' specified and valid. */
1662 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1663 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1666 /* Relative width `:relative-width FACTOR' specified and valid.
1667 Compute the width of the characters having the `glyph'
1670 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1673 if (it
->multibyte_p
)
1675 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1676 - IT_BYTEPOS (*it
));
1677 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1680 it2
.c
= *p
, it2
.len
= 1;
1682 it2
.glyph_row
= NULL
;
1683 it2
.what
= IT_CHARACTER
;
1684 x_produce_glyphs (&it2
);
1685 width
= NUMVAL (prop
) * it2
.pixel_width
;
1687 else if (prop
= Fplist_get (plist
, QCalign_to
),
1689 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1691 /* Nothing specified -> width defaults to canonical char width. */
1692 width
= CANON_X_UNIT (it
->f
);
1694 /* Compute height. */
1695 if (prop
= Fplist_get (plist
, QCheight
),
1697 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1698 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1700 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1702 height
= FONT_HEIGHT (font
);
1704 /* Compute percentage of height used for ascent. If
1705 `:ascent ASCENT' is present and valid, use that. Otherwise,
1706 derive the ascent from the font in use. */
1707 if (prop
= Fplist_get (plist
, QCascent
),
1708 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1709 ascent
= NUMVAL (prop
) / 100.0;
1711 ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1720 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1721 if (!STRINGP (object
))
1722 object
= it
->w
->buffer
;
1723 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1726 it
->pixel_width
= width
;
1727 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1728 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1731 if (face
->box
!= FACE_NO_BOX
)
1733 if (face
->box_line_width
> 0)
1735 it
->ascent
+= face
->box_line_width
;
1736 it
->descent
+= face
->box_line_width
;
1739 if (it
->start_of_box_run_p
)
1740 it
->pixel_width
+= abs (face
->box_line_width
);
1741 if (it
->end_of_box_run_p
)
1742 it
->pixel_width
+= abs (face
->box_line_width
);
1745 take_vertical_position_into_account (it
);
1748 /* Return proper value to be used as baseline offset of font that has
1749 ASCENT and DESCENT to draw characters by the font at the vertical
1750 center of the line of frame F.
1752 Here, out task is to find the value of BOFF in the following figure;
1754 -------------------------+-----------+-
1755 -+-+---------+-+ | |
1757 | | | | F_ASCENT F_HEIGHT
1760 | | |-|-+------+-----------|------- baseline
1762 | |---------|-+-+ | |
1764 -+-+---------+-+ F_DESCENT |
1765 -------------------------+-----------+-
1767 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1768 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1769 DESCENT = FONT->descent
1770 HEIGHT = FONT_HEIGHT (FONT)
1771 F_DESCENT = (F->output_data.x->font->descent
1772 - F->output_data.x->baseline_offset)
1773 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1776 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1778 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
1779 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
1780 - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
1782 /* Produce glyphs/get display metrics for the display element IT is
1783 loaded with. See the description of struct display_iterator in
1784 dispextern.h for an overview of struct display_iterator. */
1787 x_produce_glyphs (it
)
1790 it
->glyph_not_available_p
= 0;
1792 if (it
->what
== IT_CHARACTER
)
1796 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1798 int font_not_found_p
;
1799 struct font_info
*font_info
;
1800 int boff
; /* baseline offset */
1801 /* We may change it->multibyte_p upon unibyte<->multibyte
1802 conversion. So, save the current value now and restore it
1805 Note: It seems that we don't have to record multibyte_p in
1806 struct glyph because the character code itself tells if or
1807 not the character is multibyte. Thus, in the future, we must
1808 consider eliminating the field `multibyte_p' in the struct
1811 int saved_multibyte_p
= it
->multibyte_p
;
1813 /* Maybe translate single-byte characters to multibyte, or the
1815 it
->char_to_display
= it
->c
;
1816 if (!ASCII_BYTE_P (it
->c
))
1818 if (unibyte_display_via_language_environment
1819 && SINGLE_BYTE_CHAR_P (it
->c
)
1821 || !NILP (Vnonascii_translation_table
)))
1823 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
1824 it
->multibyte_p
= 1;
1825 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1826 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1828 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
1829 && !it
->multibyte_p
)
1831 it
->char_to_display
= multibyte_char_to_unibyte (it
->c
, Qnil
);
1832 it
->multibyte_p
= 0;
1833 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1834 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1838 /* Get font to use. Encode IT->char_to_display. */
1839 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
1840 it
->face_id
, &char2b
,
1844 /* When no suitable font found, use the default font. */
1845 font_not_found_p
= font
== NULL
;
1846 if (font_not_found_p
)
1848 font
= FRAME_FONT (it
->f
);
1849 boff
= it
->f
->output_data
.x
->baseline_offset
;
1854 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
1855 boff
= font_info
->baseline_offset
;
1856 if (font_info
->vertical_centering
)
1857 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
1860 if (it
->char_to_display
>= ' '
1861 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
1863 /* Either unibyte or ASCII. */
1868 pcm
= x_per_char_metric (font
, &char2b
);
1869 it
->ascent
= font
->ascent
+ boff
;
1870 it
->descent
= font
->descent
- boff
;
1874 it
->phys_ascent
= pcm
->ascent
+ boff
;
1875 it
->phys_descent
= pcm
->descent
- boff
;
1876 it
->pixel_width
= pcm
->width
;
1880 it
->glyph_not_available_p
= 1;
1881 it
->phys_ascent
= font
->ascent
+ boff
;
1882 it
->phys_descent
= font
->descent
- boff
;
1883 it
->pixel_width
= FONT_WIDTH (font
);
1886 /* If this is a space inside a region of text with
1887 `space-width' property, change its width. */
1888 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
1890 it
->pixel_width
*= XFLOATINT (it
->space_width
);
1892 /* If face has a box, add the box thickness to the character
1893 height. If character has a box line to the left and/or
1894 right, add the box line width to the character's width. */
1895 if (face
->box
!= FACE_NO_BOX
)
1897 int thick
= face
->box_line_width
;
1901 it
->ascent
+= thick
;
1902 it
->descent
+= thick
;
1907 if (it
->start_of_box_run_p
)
1908 it
->pixel_width
+= thick
;
1909 if (it
->end_of_box_run_p
)
1910 it
->pixel_width
+= thick
;
1913 /* If face has an overline, add the height of the overline
1914 (1 pixel) and a 1 pixel margin to the character height. */
1915 if (face
->overline_p
)
1918 take_vertical_position_into_account (it
);
1920 /* If we have to actually produce glyphs, do it. */
1925 /* Translate a space with a `space-width' property
1926 into a stretch glyph. */
1927 double ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1928 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1929 it
->ascent
+ it
->descent
, ascent
);
1932 x_append_glyph (it
);
1934 /* If characters with lbearing or rbearing are displayed
1935 in this line, record that fact in a flag of the
1936 glyph row. This is used to optimize X output code. */
1937 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
1938 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1941 else if (it
->char_to_display
== '\n')
1943 /* A newline has no width but we need the height of the line. */
1944 it
->pixel_width
= 0;
1946 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1947 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1949 if (face
->box
!= FACE_NO_BOX
1950 && face
->box_line_width
> 0)
1952 it
->ascent
+= face
->box_line_width
;
1953 it
->descent
+= face
->box_line_width
;
1956 else if (it
->char_to_display
== '\t')
1958 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
1959 int x
= it
->current_x
+ it
->continuation_lines_width
;
1960 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
1962 /* If the distance from the current position to the next tab
1963 stop is less than a canonical character width, use the
1964 tab stop after that. */
1965 if (next_tab_x
- x
< CANON_X_UNIT (it
->f
))
1966 next_tab_x
+= tab_width
;
1968 it
->pixel_width
= next_tab_x
- x
;
1970 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1971 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1975 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
1976 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1977 it
->ascent
+ it
->descent
, ascent
);
1982 /* A multi-byte character. Assume that the display width of the
1983 character is the width of the character multiplied by the
1984 width of the font. */
1986 /* If we found a font, this font should give us the right
1987 metrics. If we didn't find a font, use the frame's
1988 default font and calculate the width of the character
1989 from the charset width; this is what old redisplay code
1991 pcm
= x_per_char_metric (font
, &char2b
);
1992 if (font_not_found_p
|| !pcm
)
1994 int charset
= CHAR_CHARSET (it
->char_to_display
);
1996 it
->glyph_not_available_p
= 1;
1997 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
1998 * CHARSET_WIDTH (charset
));
1999 it
->phys_ascent
= font
->ascent
+ boff
;
2000 it
->phys_descent
= font
->descent
- boff
;
2004 it
->pixel_width
= pcm
->width
;
2005 it
->phys_ascent
= pcm
->ascent
+ boff
;
2006 it
->phys_descent
= pcm
->descent
- boff
;
2008 && (pcm
->lbearing
< 0
2009 || pcm
->rbearing
> pcm
->width
))
2010 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2013 it
->ascent
= font
->ascent
+ boff
;
2014 it
->descent
= font
->descent
- boff
;
2015 if (face
->box
!= FACE_NO_BOX
)
2017 int thick
= face
->box_line_width
;
2021 it
->ascent
+= thick
;
2022 it
->descent
+= thick
;
2027 if (it
->start_of_box_run_p
)
2028 it
->pixel_width
+= thick
;
2029 if (it
->end_of_box_run_p
)
2030 it
->pixel_width
+= thick
;
2033 /* If face has an overline, add the height of the overline
2034 (1 pixel) and a 1 pixel margin to the character height. */
2035 if (face
->overline_p
)
2038 take_vertical_position_into_account (it
);
2041 x_append_glyph (it
);
2043 it
->multibyte_p
= saved_multibyte_p
;
2045 else if (it
->what
== IT_COMPOSITION
)
2047 /* Note: A composition is represented as one glyph in the
2048 glyph matrix. There are no padding glyphs. */
2051 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2053 int font_not_found_p
;
2054 struct font_info
*font_info
;
2055 int boff
; /* baseline offset */
2056 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2058 /* Maybe translate single-byte characters to multibyte. */
2059 it
->char_to_display
= it
->c
;
2060 if (unibyte_display_via_language_environment
2061 && SINGLE_BYTE_CHAR_P (it
->c
)
2064 && !NILP (Vnonascii_translation_table
))))
2066 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2069 /* Get face and font to use. Encode IT->char_to_display. */
2070 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2071 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2072 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2073 it
->face_id
, &char2b
, it
->multibyte_p
);
2076 /* When no suitable font found, use the default font. */
2077 font_not_found_p
= font
== NULL
;
2078 if (font_not_found_p
)
2080 font
= FRAME_FONT (it
->f
);
2081 boff
= it
->f
->output_data
.x
->baseline_offset
;
2086 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2087 boff
= font_info
->baseline_offset
;
2088 if (font_info
->vertical_centering
)
2089 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2092 /* There are no padding glyphs, so there is only one glyph to
2093 produce for the composition. Important is that pixel_width,
2094 ascent and descent are the values of what is drawn by
2095 draw_glyphs (i.e. the values of the overall glyphs composed). */
2098 /* If we have not yet calculated pixel size data of glyphs of
2099 the composition for the current face font, calculate them
2100 now. Theoretically, we have to check all fonts for the
2101 glyphs, but that requires much time and memory space. So,
2102 here we check only the font of the first glyph. This leads
2103 to incorrect display very rarely, and C-l (recenter) can
2104 correct the display anyway. */
2105 if (cmp
->font
!= (void *) font
)
2107 /* Ascent and descent of the font of the first character of
2108 this composition (adjusted by baseline offset). Ascent
2109 and descent of overall glyphs should not be less than
2110 them respectively. */
2111 int font_ascent
= font
->ascent
+ boff
;
2112 int font_descent
= font
->descent
- boff
;
2113 /* Bounding box of the overall glyphs. */
2114 int leftmost
, rightmost
, lowest
, highest
;
2115 int i
, width
, ascent
, descent
;
2117 cmp
->font
= (void *) font
;
2119 /* Initialize the bounding box. */
2121 && (pcm
= x_per_char_metric (font
, &char2b
)))
2124 ascent
= pcm
->ascent
;
2125 descent
= pcm
->descent
;
2129 width
= FONT_WIDTH (font
);
2130 ascent
= font
->ascent
;
2131 descent
= font
->descent
;
2135 lowest
= - descent
+ boff
;
2136 highest
= ascent
+ boff
;
2140 && font_info
->default_ascent
2141 && CHAR_TABLE_P (Vuse_default_ascent
)
2142 && !NILP (Faref (Vuse_default_ascent
,
2143 make_number (it
->char_to_display
))))
2144 highest
= font_info
->default_ascent
+ boff
;
2146 /* Draw the first glyph at the normal position. It may be
2147 shifted to right later if some other glyphs are drawn at
2149 cmp
->offsets
[0] = 0;
2150 cmp
->offsets
[1] = boff
;
2152 /* Set cmp->offsets for the remaining glyphs. */
2153 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2155 int left
, right
, btm
, top
;
2156 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2157 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2159 face
= FACE_FROM_ID (it
->f
, face_id
);
2160 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2165 font
= FRAME_FONT (it
->f
);
2166 boff
= it
->f
->output_data
.x
->baseline_offset
;
2172 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2173 boff
= font_info
->baseline_offset
;
2174 if (font_info
->vertical_centering
)
2175 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2179 && (pcm
= x_per_char_metric (font
, &char2b
)))
2182 ascent
= pcm
->ascent
;
2183 descent
= pcm
->descent
;
2187 width
= FONT_WIDTH (font
);
2192 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2194 /* Relative composition with or without
2196 left
= (leftmost
+ rightmost
- width
) / 2;
2197 btm
= - descent
+ boff
;
2198 if (font_info
&& font_info
->relative_compose
2199 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2200 || NILP (Faref (Vignore_relative_composition
,
2201 make_number (ch
)))))
2204 if (- descent
>= font_info
->relative_compose
)
2205 /* One extra pixel between two glyphs. */
2207 else if (ascent
<= 0)
2208 /* One extra pixel between two glyphs. */
2209 btm
= lowest
- 1 - ascent
- descent
;
2214 /* A composition rule is specified by an integer
2215 value that encodes global and new reference
2216 points (GREF and NREF). GREF and NREF are
2217 specified by numbers as below:
2225 ---3---4---5--- baseline
2227 6---7---8 -- descent
2229 int rule
= COMPOSITION_RULE (cmp
, i
);
2230 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2232 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2233 grefx
= gref
% 3, nrefx
= nref
% 3;
2234 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2237 + grefx
* (rightmost
- leftmost
) / 2
2238 - nrefx
* width
/ 2);
2239 btm
= ((grefy
== 0 ? highest
2241 : grefy
== 2 ? lowest
2242 : (highest
+ lowest
) / 2)
2243 - (nrefy
== 0 ? ascent
+ descent
2244 : nrefy
== 1 ? descent
- boff
2246 : (ascent
+ descent
) / 2));
2249 cmp
->offsets
[i
* 2] = left
;
2250 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2252 /* Update the bounding box of the overall glyphs. */
2253 right
= left
+ width
;
2254 top
= btm
+ descent
+ ascent
;
2255 if (left
< leftmost
)
2257 if (right
> rightmost
)
2265 /* If there are glyphs whose x-offsets are negative,
2266 shift all glyphs to the right and make all x-offsets
2270 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2271 cmp
->offsets
[i
* 2] -= leftmost
;
2272 rightmost
-= leftmost
;
2275 cmp
->pixel_width
= rightmost
;
2276 cmp
->ascent
= highest
;
2277 cmp
->descent
= - lowest
;
2278 if (cmp
->ascent
< font_ascent
)
2279 cmp
->ascent
= font_ascent
;
2280 if (cmp
->descent
< font_descent
)
2281 cmp
->descent
= font_descent
;
2284 it
->pixel_width
= cmp
->pixel_width
;
2285 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2286 it
->descent
= it
->phys_descent
= cmp
->descent
;
2288 if (face
->box
!= FACE_NO_BOX
)
2290 int thick
= face
->box_line_width
;
2294 it
->ascent
+= thick
;
2295 it
->descent
+= thick
;
2300 if (it
->start_of_box_run_p
)
2301 it
->pixel_width
+= thick
;
2302 if (it
->end_of_box_run_p
)
2303 it
->pixel_width
+= thick
;
2306 /* If face has an overline, add the height of the overline
2307 (1 pixel) and a 1 pixel margin to the character height. */
2308 if (face
->overline_p
)
2311 take_vertical_position_into_account (it
);
2314 x_append_composite_glyph (it
);
2316 else if (it
->what
== IT_IMAGE
)
2317 x_produce_image_glyph (it
);
2318 else if (it
->what
== IT_STRETCH
)
2319 x_produce_stretch_glyph (it
);
2321 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2322 because this isn't true for images with `:ascent 100'. */
2323 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2324 if (it
->area
== TEXT_AREA
)
2325 it
->current_x
+= it
->pixel_width
;
2327 it
->descent
+= it
->extra_line_spacing
;
2329 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2330 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2331 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2332 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2336 /* Estimate the pixel height of the mode or top line on frame F.
2337 FACE_ID specifies what line's height to estimate. */
2340 x_estimate_mode_line_height (f
, face_id
)
2342 enum face_id face_id
;
2344 int height
= FONT_HEIGHT (FRAME_FONT (f
));
2346 /* This function is called so early when Emacs starts that the face
2347 cache and mode line face are not yet initialized. */
2348 if (FRAME_FACE_CACHE (f
))
2350 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2354 height
= FONT_HEIGHT (face
->font
);
2355 if (face
->box_line_width
> 0)
2356 height
+= 2 * face
->box_line_width
;
2364 /***********************************************************************
2366 ***********************************************************************/
2368 /* A sequence of glyphs to be drawn in the same face.
2370 This data structure is not really completely X specific, so it
2371 could possibly, at least partially, be useful for other systems. It
2372 is currently not part of the external redisplay interface because
2373 it's not clear what other systems will need. */
2377 /* X-origin of the string. */
2380 /* Y-origin and y-position of the base line of this string. */
2383 /* The width of the string, not including a face extension. */
2386 /* The width of the string, including a face extension. */
2387 int background_width
;
2389 /* The height of this string. This is the height of the line this
2390 string is drawn in, and can be different from the height of the
2391 font the string is drawn in. */
2394 /* Number of pixels this string overwrites in front of its x-origin.
2395 This number is zero if the string has an lbearing >= 0; it is
2396 -lbearing, if the string has an lbearing < 0. */
2399 /* Number of pixels this string overwrites past its right-most
2400 nominal x-position, i.e. x + width. Zero if the string's
2401 rbearing is <= its nominal width, rbearing - width otherwise. */
2404 /* The frame on which the glyph string is drawn. */
2407 /* The window on which the glyph string is drawn. */
2410 /* X display and window for convenience. */
2414 /* The glyph row for which this string was built. It determines the
2415 y-origin and height of the string. */
2416 struct glyph_row
*row
;
2418 /* The area within row. */
2419 enum glyph_row_area area
;
2421 /* Characters to be drawn, and number of characters. */
2425 /* A face-override for drawing cursors, mouse face and similar. */
2426 enum draw_glyphs_face hl
;
2428 /* Face in which this string is to be drawn. */
2431 /* Font in which this string is to be drawn. */
2434 /* Font info for this string. */
2435 struct font_info
*font_info
;
2437 /* Non-null means this string describes (part of) a composition.
2438 All characters from char2b are drawn composed. */
2439 struct composition
*cmp
;
2441 /* Index of this glyph string's first character in the glyph
2442 definition of CMP. If this is zero, this glyph string describes
2443 the first character of a composition. */
2446 /* 1 means this glyph strings face has to be drawn to the right end
2447 of the window's drawing area. */
2448 unsigned extends_to_end_of_line_p
: 1;
2450 /* 1 means the background of this string has been drawn. */
2451 unsigned background_filled_p
: 1;
2453 /* 1 means glyph string must be drawn with 16-bit functions. */
2454 unsigned two_byte_p
: 1;
2456 /* 1 means that the original font determined for drawing this glyph
2457 string could not be loaded. The member `font' has been set to
2458 the frame's default font in this case. */
2459 unsigned font_not_found_p
: 1;
2461 /* 1 means that the face in which this glyph string is drawn has a
2463 unsigned stippled_p
: 1;
2465 /* 1 means only the foreground of this glyph string must be drawn,
2466 and we should use the physical height of the line this glyph
2467 string appears in as clip rect. */
2468 unsigned for_overlaps_p
: 1;
2470 /* The GC to use for drawing this glyph string. */
2473 /* A pointer to the first glyph in the string. This glyph
2474 corresponds to char2b[0]. Needed to draw rectangles if
2475 font_not_found_p is 1. */
2476 struct glyph
*first_glyph
;
2478 /* Image, if any. */
2481 struct glyph_string
*next
, *prev
;
2488 x_dump_glyph_string (s
)
2489 struct glyph_string
*s
;
2491 fprintf (stderr
, "glyph string\n");
2492 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2493 s
->x
, s
->y
, s
->width
, s
->height
);
2494 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2495 fprintf (stderr
, " hl = %d\n", s
->hl
);
2496 fprintf (stderr
, " left overhang = %d, right = %d\n",
2497 s
->left_overhang
, s
->right_overhang
);
2498 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2499 fprintf (stderr
, " extends to end of line = %d\n",
2500 s
->extends_to_end_of_line_p
);
2501 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2502 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2505 #endif /* GLYPH_DEBUG */
2509 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2510 struct glyph_string
**,
2511 struct glyph_string
*,
2512 struct glyph_string
*));
2513 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2514 struct glyph_string
**,
2515 struct glyph_string
*,
2516 struct glyph_string
*));
2517 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2518 struct glyph_string
**,
2519 struct glyph_string
*));
2520 static int x_left_overwritten
P_ ((struct glyph_string
*));
2521 static int x_left_overwriting
P_ ((struct glyph_string
*));
2522 static int x_right_overwritten
P_ ((struct glyph_string
*));
2523 static int x_right_overwriting
P_ ((struct glyph_string
*));
2524 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2526 static void x_init_glyph_string
P_ ((struct glyph_string
*,
2527 XChar2b
*, struct window
*,
2529 enum glyph_row_area
, int,
2530 enum draw_glyphs_face
));
2531 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2532 enum glyph_row_area
, int, int,
2533 enum draw_glyphs_face
, int *, int *, int));
2534 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2535 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2536 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2538 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2539 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2540 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2541 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2542 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2543 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2544 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2545 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2546 static void x_get_glyph_overhangs
P_ ((struct glyph
*, struct frame
*,
2548 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2549 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
2550 unsigned long *, double, int));
2551 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2552 double, int, unsigned long));
2553 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2554 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2555 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2556 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2557 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
2558 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2559 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2561 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2562 int, int, int, int, XRectangle
*));
2563 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2564 int, int, int, XRectangle
*));
2565 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2566 enum glyph_row_area
));
2567 static int x_fill_stretch_glyph_string
P_ ((struct glyph_string
*,
2569 enum glyph_row_area
, int, int));
2572 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2576 /* Append the list of glyph strings with head H and tail T to the list
2577 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2580 x_append_glyph_string_lists (head
, tail
, h
, t
)
2581 struct glyph_string
**head
, **tail
;
2582 struct glyph_string
*h
, *t
;
2596 /* Prepend the list of glyph strings with head H and tail T to the
2597 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2601 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2602 struct glyph_string
**head
, **tail
;
2603 struct glyph_string
*h
, *t
;
2617 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2618 Set *HEAD and *TAIL to the resulting list. */
2621 x_append_glyph_string (head
, tail
, s
)
2622 struct glyph_string
**head
, **tail
;
2623 struct glyph_string
*s
;
2625 s
->next
= s
->prev
= NULL
;
2626 x_append_glyph_string_lists (head
, tail
, s
, s
);
2630 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2635 struct glyph_string
*s
;
2637 if (s
->font
== FRAME_FONT (s
->f
)
2638 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2639 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2641 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
2644 /* Cursor on non-default face: must merge. */
2648 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
2649 xgcv
.foreground
= s
->face
->background
;
2651 /* If the glyph would be invisible, try a different foreground. */
2652 if (xgcv
.foreground
== xgcv
.background
)
2653 xgcv
.foreground
= s
->face
->foreground
;
2654 if (xgcv
.foreground
== xgcv
.background
)
2655 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
2656 if (xgcv
.foreground
== xgcv
.background
)
2657 xgcv
.foreground
= s
->face
->foreground
;
2659 /* Make sure the cursor is distinct from text in this face. */
2660 if (xgcv
.background
== s
->face
->background
2661 && xgcv
.foreground
== s
->face
->foreground
)
2663 xgcv
.background
= s
->face
->foreground
;
2664 xgcv
.foreground
= s
->face
->background
;
2667 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2668 xgcv
.font
= s
->font
->fid
;
2669 xgcv
.graphics_exposures
= False
;
2670 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2672 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2673 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2676 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2677 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2679 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2684 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2687 x_set_mouse_face_gc (s
)
2688 struct glyph_string
*s
;
2693 /* What face has to be used last for the mouse face? */
2694 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2695 face
= FACE_FROM_ID (s
->f
, face_id
);
2697 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
2699 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2700 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2702 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2703 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2704 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2706 /* If font in this face is same as S->font, use it. */
2707 if (s
->font
== s
->face
->font
)
2708 s
->gc
= s
->face
->gc
;
2711 /* Otherwise construct scratch_cursor_gc with values from FACE
2716 xgcv
.background
= s
->face
->background
;
2717 xgcv
.foreground
= s
->face
->foreground
;
2718 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2719 xgcv
.font
= s
->font
->fid
;
2720 xgcv
.graphics_exposures
= False
;
2721 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2723 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2724 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2727 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2728 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2730 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2733 xassert (s
->gc
!= 0);
2737 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2738 Faces to use in the mode line have already been computed when the
2739 matrix was built, so there isn't much to do, here. */
2742 x_set_mode_line_face_gc (s
)
2743 struct glyph_string
*s
;
2745 s
->gc
= s
->face
->gc
;
2749 /* Set S->gc of glyph string S for drawing that glyph string. Set
2750 S->stippled_p to a non-zero value if the face of S has a stipple
2754 x_set_glyph_string_gc (s
)
2755 struct glyph_string
*s
;
2757 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2759 if (s
->hl
== DRAW_NORMAL_TEXT
)
2761 s
->gc
= s
->face
->gc
;
2762 s
->stippled_p
= s
->face
->stipple
!= 0;
2764 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2766 x_set_mode_line_face_gc (s
);
2767 s
->stippled_p
= s
->face
->stipple
!= 0;
2769 else if (s
->hl
== DRAW_CURSOR
)
2771 x_set_cursor_gc (s
);
2774 else if (s
->hl
== DRAW_MOUSE_FACE
)
2776 x_set_mouse_face_gc (s
);
2777 s
->stippled_p
= s
->face
->stipple
!= 0;
2779 else if (s
->hl
== DRAW_IMAGE_RAISED
2780 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2782 s
->gc
= s
->face
->gc
;
2783 s
->stippled_p
= s
->face
->stipple
!= 0;
2787 s
->gc
= s
->face
->gc
;
2788 s
->stippled_p
= s
->face
->stipple
!= 0;
2791 /* GC must have been set. */
2792 xassert (s
->gc
!= 0);
2796 /* Return in *R the clipping rectangle for glyph string S. */
2799 x_get_glyph_string_clip_rect (s
, r
)
2800 struct glyph_string
*s
;
2803 if (s
->row
->full_width_p
)
2805 /* Draw full-width. X coordinates are relative to S->w->left. */
2806 int canon_x
= CANON_X_UNIT (s
->f
);
2808 r
->x
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
2809 r
->width
= XFASTINT (s
->w
->width
) * canon_x
;
2811 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
2813 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
2814 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
2818 r
->x
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
2820 /* Unless displaying a mode or menu bar line, which are always
2821 fully visible, clip to the visible part of the row. */
2822 if (s
->w
->pseudo_window_p
)
2823 r
->height
= s
->row
->visible_height
;
2825 r
->height
= s
->height
;
2829 /* This is a text line that may be partially visible. */
2830 r
->x
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
2831 r
->width
= window_box_width (s
->w
, s
->area
);
2832 r
->height
= s
->row
->visible_height
;
2835 /* Don't use S->y for clipping because it doesn't take partially
2836 visible lines into account. For example, it can be negative for
2837 partially visible lines at the top of a window. */
2838 if (!s
->row
->full_width_p
2839 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2840 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2842 r
->y
= max (0, s
->row
->y
);
2844 /* If drawing a tool-bar window, draw it over the internal border
2845 at the top of the window. */
2846 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
2847 r
->y
-= s
->f
->output_data
.x
->internal_border_width
;
2849 /* If S draws overlapping rows, it's sufficient to use the top and
2850 bottom of the window for clipping because this glyph string
2851 intentionally draws over other lines. */
2852 if (s
->for_overlaps_p
)
2854 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2855 r
->height
= window_text_bottom_y (s
->w
) - r
->y
;
2858 r
->y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->y
);
2862 /* Set clipping for output of glyph string S. S may be part of a mode
2863 line or menu if we don't have X toolkit support. */
2866 x_set_glyph_string_clipping (s
)
2867 struct glyph_string
*s
;
2870 x_get_glyph_string_clip_rect (s
, &r
);
2871 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
2875 /* Compute left and right overhang of glyph string S. If S is a glyph
2876 string for a composition, assume overhangs don't exist. */
2879 x_compute_glyph_string_overhangs (s
)
2880 struct glyph_string
*s
;
2883 && s
->first_glyph
->type
== CHAR_GLYPH
)
2886 int direction
, font_ascent
, font_descent
;
2887 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
2888 &font_ascent
, &font_descent
, &cs
);
2889 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2890 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2895 /* Compute overhangs and x-positions for glyph string S and its
2896 predecessors, or successors. X is the starting x-position for S.
2897 BACKWARD_P non-zero means process predecessors. */
2900 x_compute_overhangs_and_x (s
, x
, backward_p
)
2901 struct glyph_string
*s
;
2909 x_compute_glyph_string_overhangs (s
);
2919 x_compute_glyph_string_overhangs (s
);
2928 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2929 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2930 assumed to be zero. */
2933 x_get_glyph_overhangs (glyph
, f
, left
, right
)
2934 struct glyph
*glyph
;
2940 if (glyph
->type
== CHAR_GLYPH
)
2944 struct font_info
*font_info
;
2948 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
2950 font_info
= FONT_INFO_FROM_ID (f
, face
->font_info_id
);
2952 && (pcm
= x_per_char_metric (font
, &char2b
)))
2954 if (pcm
->rbearing
> pcm
->width
)
2955 *right
= pcm
->rbearing
- pcm
->width
;
2956 if (pcm
->lbearing
< 0)
2957 *left
= -pcm
->lbearing
;
2963 /* Return the index of the first glyph preceding glyph string S that
2964 is overwritten by S because of S's left overhang. Value is -1
2965 if no glyphs are overwritten. */
2968 x_left_overwritten (s
)
2969 struct glyph_string
*s
;
2973 if (s
->left_overhang
)
2976 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2977 int first
= s
->first_glyph
- glyphs
;
2979 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
2980 x
-= glyphs
[i
].pixel_width
;
2991 /* Return the index of the first glyph preceding glyph string S that
2992 is overwriting S because of its right overhang. Value is -1 if no
2993 glyph in front of S overwrites S. */
2996 x_left_overwriting (s
)
2997 struct glyph_string
*s
;
3000 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3001 int first
= s
->first_glyph
- glyphs
;
3005 for (i
= first
- 1; i
>= 0; --i
)
3008 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3011 x
-= glyphs
[i
].pixel_width
;
3018 /* Return the index of the last glyph following glyph string S that is
3019 not overwritten by S because of S's right overhang. Value is -1 if
3020 no such glyph is found. */
3023 x_right_overwritten (s
)
3024 struct glyph_string
*s
;
3028 if (s
->right_overhang
)
3031 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3032 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3033 int end
= s
->row
->used
[s
->area
];
3035 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3036 x
+= glyphs
[i
].pixel_width
;
3045 /* Return the index of the last glyph following glyph string S that
3046 overwrites S because of its left overhang. Value is negative
3047 if no such glyph is found. */
3050 x_right_overwriting (s
)
3051 struct glyph_string
*s
;
3054 int end
= s
->row
->used
[s
->area
];
3055 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3056 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3060 for (i
= first
; i
< end
; ++i
)
3063 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3066 x
+= glyphs
[i
].pixel_width
;
3073 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3076 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3077 struct glyph_string
*s
;
3081 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
3082 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3083 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3084 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3088 /* Draw the background of glyph_string S. If S->background_filled_p
3089 is non-zero don't draw it. FORCE_P non-zero means draw the
3090 background even if it wouldn't be drawn normally. This is used
3091 when a string preceding S draws into the background of S, or S
3092 contains the first component of a composition. */
3095 x_draw_glyph_string_background (s
, force_p
)
3096 struct glyph_string
*s
;
3099 /* Nothing to do if background has already been drawn or if it
3100 shouldn't be drawn in the first place. */
3101 if (!s
->background_filled_p
)
3103 int box_line_width
= max (s
->face
->box_line_width
, 0);
3107 /* Fill background with a stipple pattern. */
3108 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3109 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3110 s
->y
+ box_line_width
,
3111 s
->background_width
,
3112 s
->height
- 2 * box_line_width
);
3113 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3114 s
->background_filled_p
= 1;
3116 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
3117 || s
->font_not_found_p
3118 || s
->extends_to_end_of_line_p
3121 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
3122 s
->background_width
,
3123 s
->height
- 2 * box_line_width
);
3124 s
->background_filled_p
= 1;
3130 /* Draw the foreground of glyph string S. */
3133 x_draw_glyph_string_foreground (s
)
3134 struct glyph_string
*s
;
3138 /* If first glyph of S has a left box line, start drawing the text
3139 of S to the right of that box line. */
3140 if (s
->face
->box
!= FACE_NO_BOX
3141 && s
->first_glyph
->left_box_line_p
)
3142 x
= s
->x
+ abs (s
->face
->box_line_width
);
3146 /* Draw characters of S as rectangles if S's font could not be
3148 if (s
->font_not_found_p
)
3150 for (i
= 0; i
< s
->nchars
; ++i
)
3152 struct glyph
*g
= s
->first_glyph
+ i
;
3153 XDrawRectangle (s
->display
, s
->window
,
3154 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3156 x
+= g
->pixel_width
;
3161 char *char1b
= (char *) s
->char2b
;
3162 int boff
= s
->font_info
->baseline_offset
;
3164 if (s
->font_info
->vertical_centering
)
3165 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3167 /* If we can use 8-bit functions, condense S->char2b. */
3169 for (i
= 0; i
< s
->nchars
; ++i
)
3170 char1b
[i
] = s
->char2b
[i
].byte2
;
3172 /* Draw text with XDrawString if background has already been
3173 filled. Otherwise, use XDrawImageString. (Note that
3174 XDrawImageString is usually faster than XDrawString.) Always
3175 use XDrawImageString when drawing the cursor so that there is
3176 no chance that characters under a box cursor are invisible. */
3177 if (s
->for_overlaps_p
3178 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3180 /* Draw characters with 16-bit or 8-bit functions. */
3182 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
3183 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3185 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
3186 s
->ybase
- boff
, char1b
, s
->nchars
);
3191 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
3192 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3194 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
3195 s
->ybase
- boff
, char1b
, s
->nchars
);
3200 /* Draw the foreground of composite glyph string S. */
3203 x_draw_composite_glyph_string_foreground (s
)
3204 struct glyph_string
*s
;
3208 /* If first glyph of S has a left box line, start drawing the text
3209 of S to the right of that box line. */
3210 if (s
->face
->box
!= FACE_NO_BOX
3211 && s
->first_glyph
->left_box_line_p
)
3212 x
= s
->x
+ abs (s
->face
->box_line_width
);
3216 /* S is a glyph string for a composition. S->gidx is the index of
3217 the first character drawn for glyphs of this composition.
3218 S->gidx == 0 means we are drawing the very first character of
3219 this composition. */
3221 /* Draw a rectangle for the composition if the font for the very
3222 first character of the composition could not be loaded. */
3223 if (s
->font_not_found_p
)
3226 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
3227 s
->width
- 1, s
->height
- 1);
3231 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3232 XDrawString16 (s
->display
, s
->window
, s
->gc
,
3233 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3234 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3240 #ifdef USE_X_TOOLKIT
3242 static struct frame
*x_frame_of_widget
P_ ((Widget
));
3245 /* Return the frame on which widget WIDGET is used.. Abort if frame
3246 cannot be determined. */
3248 static struct frame
*
3249 x_frame_of_widget (widget
)
3252 struct x_display_info
*dpyinfo
;
3256 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3258 /* Find the top-level shell of the widget. Note that this function
3259 can be called when the widget is not yet realized, so XtWindow
3260 (widget) == 0. That's the reason we can't simply use
3261 x_any_window_to_frame. */
3262 while (!XtIsTopLevelShell (widget
))
3263 widget
= XtParent (widget
);
3265 /* Look for a frame with that top-level widget. Allocate the color
3266 on that frame to get the right gamma correction value. */
3267 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3268 if (GC_FRAMEP (XCAR (tail
))
3269 && (f
= XFRAME (XCAR (tail
)),
3270 (f
->output_data
.nothing
!= 1
3271 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3272 && f
->output_data
.x
->widget
== widget
)
3279 /* Allocate the color COLOR->pixel on the screen and display of
3280 widget WIDGET in colormap CMAP. If an exact match cannot be
3281 allocated, try the nearest color available. Value is non-zero
3282 if successful. This is called from lwlib. */
3285 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3290 struct frame
*f
= x_frame_of_widget (widget
);
3291 return x_alloc_nearest_color (f
, cmap
, color
);
3295 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3296 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3297 If this produces the same color as PIXEL, try a color where all RGB
3298 values have DELTA added. Return the allocated color in *PIXEL.
3299 DISPLAY is the X display, CMAP is the colormap to operate on.
3300 Value is non-zero if successful. */
3303 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
3307 unsigned long *pixel
;
3311 struct frame
*f
= x_frame_of_widget (widget
);
3312 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
3316 #endif /* USE_X_TOOLKIT */
3319 /* Value is an array of XColor structures for the contents of the
3320 color map of frame F. Set *NCELLS to the size of the array.
3321 Note that this probably shouldn't be called for large color maps,
3322 say a 24-bit TrueColor map. */
3324 static const XColor
*
3325 x_color_cells (f
, ncells
)
3329 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3331 if (dpyinfo
->color_cells
== NULL
)
3333 Display
*display
= FRAME_X_DISPLAY (f
);
3334 Screen
*screen
= FRAME_X_SCREEN (f
);
3337 dpyinfo
->ncolor_cells
3338 = XDisplayCells (display
, XScreenNumberOfScreen (screen
));
3339 dpyinfo
->color_cells
3340 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
3341 * sizeof *dpyinfo
->color_cells
);
3343 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
3344 dpyinfo
->color_cells
[i
].pixel
= i
;
3346 XQueryColors (display
, FRAME_X_COLORMAP (f
),
3347 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
3350 *ncells
= dpyinfo
->ncolor_cells
;
3351 return dpyinfo
->color_cells
;
3355 /* On frame F, translate pixel colors to RGB values for the NCOLORS
3356 colors in COLORS. Use cached information, if available. */
3359 x_query_colors (f
, colors
, ncolors
)
3364 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3366 if (dpyinfo
->color_cells
)
3369 for (i
= 0; i
< ncolors
; ++i
)
3371 unsigned long pixel
= colors
[i
].pixel
;
3372 xassert (pixel
< dpyinfo
->ncolor_cells
);
3373 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
3374 colors
[i
] = dpyinfo
->color_cells
[pixel
];
3378 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
3382 /* On frame F, translate pixel color to RGB values for the color in
3383 COLOR. Use cached information, if available. */
3386 x_query_color (f
, color
)
3390 x_query_colors (f
, color
, 1);
3394 /* Allocate the color COLOR->pixel on SCREEN of DISPLAY, colormap
3395 CMAP. If an exact match can't be allocated, try the nearest color
3396 available. Value is non-zero if successful. Set *COLOR to the
3400 x_alloc_nearest_color (f
, cmap
, color
)
3405 Display
*display
= FRAME_X_DISPLAY (f
);
3406 Screen
*screen
= FRAME_X_SCREEN (f
);
3409 gamma_correct (f
, color
);
3410 rc
= XAllocColor (display
, cmap
, color
);
3413 /* If we got to this point, the colormap is full, so we're going
3414 to try to get the next closest color. The algorithm used is
3415 a least-squares matching, which is what X uses for closest
3416 color matching with StaticColor visuals. */
3418 unsigned long nearest_delta
= ~0;
3420 const XColor
*cells
= x_color_cells (f
, &ncells
);
3422 for (nearest
= i
= 0; i
< ncells
; ++i
)
3424 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3425 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3426 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3427 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3429 if (delta
< nearest_delta
)
3432 nearest_delta
= delta
;
3436 color
->red
= cells
[nearest
].red
;
3437 color
->green
= cells
[nearest
].green
;
3438 color
->blue
= cells
[nearest
].blue
;
3439 rc
= XAllocColor (display
, cmap
, color
);
3443 /* If allocation succeeded, and the allocated pixel color is not
3444 equal to a cached pixel color recorded earlier, there was a
3445 change in the colormap, so clear the color cache. */
3446 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3447 XColor
*cached_color
;
3449 if (dpyinfo
->color_cells
3450 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
3451 (cached_color
->red
!= color
->red
3452 || cached_color
->blue
!= color
->blue
3453 || cached_color
->green
!= color
->green
)))
3455 xfree (dpyinfo
->color_cells
);
3456 dpyinfo
->color_cells
= NULL
;
3457 dpyinfo
->ncolor_cells
= 0;
3461 #ifdef DEBUG_X_COLORS
3463 register_color (color
->pixel
);
3464 #endif /* DEBUG_X_COLORS */
3470 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3471 It's necessary to do this instead of just using PIXEL directly to
3472 get color reference counts right. */
3475 x_copy_color (f
, pixel
)
3477 unsigned long pixel
;
3481 color
.pixel
= pixel
;
3483 x_query_color (f
, &color
);
3484 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3486 #ifdef DEBUG_X_COLORS
3487 register_color (pixel
);
3493 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3494 It's necessary to do this instead of just using PIXEL directly to
3495 get color reference counts right. */
3498 x_copy_dpy_color (dpy
, cmap
, pixel
)
3501 unsigned long pixel
;
3505 color
.pixel
= pixel
;
3507 XQueryColor (dpy
, cmap
, &color
);
3508 XAllocColor (dpy
, cmap
, &color
);
3510 #ifdef DEBUG_X_COLORS
3511 register_color (pixel
);
3517 /* Brightness beyond which a color won't have its highlight brightness
3520 Nominally, highlight colors for `3d' faces are calculated by
3521 brightening an object's color by a constant scale factor, but this
3522 doesn't yield good results for dark colors, so for colors who's
3523 brightness is less than this value (on a scale of 0-65535) have an
3524 use an additional additive factor.
3526 The value here is set so that the default menu-bar/mode-line color
3527 (grey75) will not have its highlights changed at all. */
3528 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
3531 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3532 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3533 If this produces the same color as PIXEL, try a color where all RGB
3534 values have DELTA added. Return the allocated color in *PIXEL.
3535 DISPLAY is the X display, CMAP is the colormap to operate on.
3536 Value is non-zero if successful. */
3539 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
3543 unsigned long *pixel
;
3551 /* Get RGB color values. */
3552 color
.pixel
= *pixel
;
3553 x_query_color (f
, &color
);
3555 /* Change RGB values by specified FACTOR. Avoid overflow! */
3556 xassert (factor
>= 0);
3557 new.red
= min (0xffff, factor
* color
.red
);
3558 new.green
= min (0xffff, factor
* color
.green
);
3559 new.blue
= min (0xffff, factor
* color
.blue
);
3561 /* Calculate brightness of COLOR. */
3562 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
3564 /* We only boost colors that are darker than
3565 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3566 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3567 /* Make an additive adjustment to NEW, because it's dark enough so
3568 that scaling by FACTOR alone isn't enough. */
3570 /* How far below the limit this color is (0 - 1, 1 being darker). */
3571 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3572 /* The additive adjustment. */
3573 int min_delta
= delta
* dimness
* factor
/ 2;
3577 new.red
= max (0, new.red
- min_delta
);
3578 new.green
= max (0, new.green
- min_delta
);
3579 new.blue
= max (0, new.blue
- min_delta
);
3583 new.red
= min (0xffff, min_delta
+ new.red
);
3584 new.green
= min (0xffff, min_delta
+ new.green
);
3585 new.blue
= min (0xffff, min_delta
+ new.blue
);
3589 /* Try to allocate the color. */
3590 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3593 if (new.pixel
== *pixel
)
3595 /* If we end up with the same color as before, try adding
3596 delta to the RGB values. */
3597 x_free_colors (f
, &new.pixel
, 1);
3599 new.red
= min (0xffff, delta
+ color
.red
);
3600 new.green
= min (0xffff, delta
+ color
.green
);
3601 new.blue
= min (0xffff, delta
+ color
.blue
);
3602 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3613 /* Set up the foreground color for drawing relief lines of glyph
3614 string S. RELIEF is a pointer to a struct relief containing the GC
3615 with which lines will be drawn. Use a color that is FACTOR or
3616 DELTA lighter or darker than the relief's background which is found
3617 in S->f->output_data.x->relief_background. If such a color cannot
3618 be allocated, use DEFAULT_PIXEL, instead. */
3621 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3623 struct relief
*relief
;
3626 unsigned long default_pixel
;
3629 struct x_output
*di
= f
->output_data
.x
;
3630 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
3631 unsigned long pixel
;
3632 unsigned long background
= di
->relief_background
;
3633 Colormap cmap
= FRAME_X_COLORMAP (f
);
3634 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3635 Display
*dpy
= FRAME_X_DISPLAY (f
);
3637 xgcv
.graphics_exposures
= False
;
3638 xgcv
.line_width
= 1;
3640 /* Free previously allocated color. The color cell will be reused
3641 when it has been freed as many times as it was allocated, so this
3642 doesn't affect faces using the same colors. */
3644 && relief
->allocated_p
)
3646 x_free_colors (f
, &relief
->pixel
, 1);
3647 relief
->allocated_p
= 0;
3650 /* Allocate new color. */
3651 xgcv
.foreground
= default_pixel
;
3653 if (dpyinfo
->n_planes
!= 1
3654 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
3656 relief
->allocated_p
= 1;
3657 xgcv
.foreground
= relief
->pixel
= pixel
;
3660 if (relief
->gc
== 0)
3662 xgcv
.stipple
= dpyinfo
->gray
;
3664 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
3667 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
3671 /* Set up colors for the relief lines around glyph string S. */
3674 x_setup_relief_colors (s
)
3675 struct glyph_string
*s
;
3677 struct x_output
*di
= s
->f
->output_data
.x
;
3678 unsigned long color
;
3680 if (s
->face
->use_box_color_for_shadows_p
)
3681 color
= s
->face
->box_color
;
3686 /* Get the background color of the face. */
3687 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3688 color
= xgcv
.background
;
3691 if (di
->white_relief
.gc
== 0
3692 || color
!= di
->relief_background
)
3694 di
->relief_background
= color
;
3695 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3696 WHITE_PIX_DEFAULT (s
->f
));
3697 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3698 BLACK_PIX_DEFAULT (s
->f
));
3703 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3704 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3705 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3706 relief. LEFT_P non-zero means draw a relief on the left side of
3707 the rectangle. RIGHT_P non-zero means draw a relief on the right
3708 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3712 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3713 raised_p
, left_p
, right_p
, clip_rect
)
3715 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3716 XRectangle
*clip_rect
;
3722 gc
= f
->output_data
.x
->white_relief
.gc
;
3724 gc
= f
->output_data
.x
->black_relief
.gc
;
3725 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3728 for (i
= 0; i
< width
; ++i
)
3729 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3730 left_x
+ i
* left_p
, top_y
+ i
,
3731 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3735 for (i
= 0; i
< width
; ++i
)
3736 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3737 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
);
3739 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3741 gc
= f
->output_data
.x
->black_relief
.gc
;
3743 gc
= f
->output_data
.x
->white_relief
.gc
;
3744 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3747 for (i
= 0; i
< width
; ++i
)
3748 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3749 left_x
+ i
* left_p
, bottom_y
- i
,
3750 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3754 for (i
= 0; i
< width
; ++i
)
3755 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3756 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3758 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3762 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3763 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3764 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3765 left side of the rectangle. RIGHT_P non-zero means draw a line
3766 on the right side of the rectangle. CLIP_RECT is the clipping
3767 rectangle to use when drawing. */
3770 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3771 left_p
, right_p
, clip_rect
)
3772 struct glyph_string
*s
;
3773 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
;
3774 XRectangle
*clip_rect
;
3778 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3779 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3780 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
3783 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3784 left_x
, top_y
, right_x
- left_x
+ 1, width
);
3788 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3789 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
3792 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3793 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
3797 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3798 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
3800 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3801 XSetClipMask (s
->display
, s
->gc
, None
);
3805 /* Draw a box around glyph string S. */
3808 x_draw_glyph_string_box (s
)
3809 struct glyph_string
*s
;
3811 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3812 int left_p
, right_p
;
3813 struct glyph
*last_glyph
;
3814 XRectangle clip_rect
;
3816 last_x
= window_box_right (s
->w
, s
->area
);
3817 if (s
->row
->full_width_p
3818 && !s
->w
->pseudo_window_p
)
3820 last_x
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s
->f
);
3821 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
3822 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
3825 /* The glyph that may have a right box line. */
3826 last_glyph
= (s
->cmp
|| s
->img
3828 : s
->first_glyph
+ s
->nchars
- 1);
3830 width
= abs (s
->face
->box_line_width
);
3831 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3833 right_x
= ((s
->row
->full_width_p
3835 : min (last_x
, s
->x
+ s
->background_width
) - 1));
3837 bottom_y
= top_y
+ s
->height
- 1;
3839 left_p
= (s
->first_glyph
->left_box_line_p
3840 || (s
->hl
== DRAW_MOUSE_FACE
3842 || s
->prev
->hl
!= s
->hl
)));
3843 right_p
= (last_glyph
->right_box_line_p
3844 || (s
->hl
== DRAW_MOUSE_FACE
3846 || s
->next
->hl
!= s
->hl
)));
3848 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3850 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3851 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3852 left_p
, right_p
, &clip_rect
);
3855 x_setup_relief_colors (s
);
3856 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3857 width
, raised_p
, left_p
, right_p
, &clip_rect
);
3862 /* Draw foreground of image glyph string S. */
3865 x_draw_image_foreground (s
)
3866 struct glyph_string
*s
;
3869 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3871 /* If first glyph of S has a left box line, start drawing it to the
3872 right of that line. */
3873 if (s
->face
->box
!= FACE_NO_BOX
3874 && s
->first_glyph
->left_box_line_p
)
3875 x
= s
->x
+ abs (s
->face
->box_line_width
);
3879 /* If there is a margin around the image, adjust x- and y-position
3881 x
+= s
->img
->hmargin
;
3882 y
+= s
->img
->vmargin
;
3888 /* We can't set both a clip mask and use XSetClipRectangles
3889 because the latter also sets a clip mask. We also can't
3890 trust on the shape extension to be available
3891 (XShapeCombineRegion). So, compute the rectangle to draw
3893 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3896 XRectangle clip_rect
, image_rect
, r
;
3898 xgcv
.clip_mask
= s
->img
->mask
;
3899 xgcv
.clip_x_origin
= x
;
3900 xgcv
.clip_y_origin
= y
;
3901 xgcv
.function
= GXcopy
;
3902 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3904 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3907 image_rect
.width
= s
->img
->width
;
3908 image_rect
.height
= s
->img
->height
;
3909 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
3910 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3911 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
3915 unsigned long mask
= GCClipXOrigin
| GCClipYOrigin
| GCFunction
;
3917 XRectangle clip_rect
, image_rect
, r
;
3919 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3922 image_rect
.width
= s
->img
->width
;
3923 image_rect
.height
= s
->img
->height
;
3924 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
3925 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3926 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
3928 /* When the image has a mask, we can expect that at
3929 least part of a mouse highlight or a block cursor will
3930 be visible. If the image doesn't have a mask, make
3931 a block cursor visible by drawing a rectangle around
3932 the image. I believe it's looking better if we do
3933 nothing here for mouse-face. */
3934 if (s
->hl
== DRAW_CURSOR
)
3935 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
3936 s
->img
->width
- 1, s
->img
->height
- 1);
3940 /* Draw a rectangle if image could not be loaded. */
3941 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
3942 s
->img
->width
- 1, s
->img
->height
- 1);
3946 /* Draw a relief around the image glyph string S. */
3949 x_draw_image_relief (s
)
3950 struct glyph_string
*s
;
3952 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3955 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3957 /* If first glyph of S has a left box line, start drawing it to the
3958 right of that line. */
3959 if (s
->face
->box
!= FACE_NO_BOX
3960 && s
->first_glyph
->left_box_line_p
)
3961 x
= s
->x
+ abs (s
->face
->box_line_width
);
3965 /* If there is a margin around the image, adjust x- and y-position
3967 x
+= s
->img
->hmargin
;
3968 y
+= s
->img
->vmargin
;
3970 if (s
->hl
== DRAW_IMAGE_SUNKEN
3971 || s
->hl
== DRAW_IMAGE_RAISED
)
3973 thick
= tool_bar_button_relief
> 0 ? tool_bar_button_relief
: 3;
3974 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3978 thick
= abs (s
->img
->relief
);
3979 raised_p
= s
->img
->relief
> 0;
3984 x1
= x
+ s
->img
->width
+ thick
- 1;
3985 y1
= y
+ s
->img
->height
+ thick
- 1;
3987 x_setup_relief_colors (s
);
3988 x_get_glyph_string_clip_rect (s
, &r
);
3989 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
3993 /* Draw the foreground of image glyph string S to PIXMAP. */
3996 x_draw_image_foreground_1 (s
, pixmap
)
3997 struct glyph_string
*s
;
4001 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
4003 /* If first glyph of S has a left box line, start drawing it to the
4004 right of that line. */
4005 if (s
->face
->box
!= FACE_NO_BOX
4006 && s
->first_glyph
->left_box_line_p
)
4007 x
= abs (s
->face
->box_line_width
);
4011 /* If there is a margin around the image, adjust x- and y-position
4013 x
+= s
->img
->hmargin
;
4014 y
+= s
->img
->vmargin
;
4020 /* We can't set both a clip mask and use XSetClipRectangles
4021 because the latter also sets a clip mask. We also can't
4022 trust on the shape extension to be available
4023 (XShapeCombineRegion). So, compute the rectangle to draw
4025 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4029 xgcv
.clip_mask
= s
->img
->mask
;
4030 xgcv
.clip_x_origin
= x
;
4031 xgcv
.clip_y_origin
= y
;
4032 xgcv
.function
= GXcopy
;
4033 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4035 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4036 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4037 XSetClipMask (s
->display
, s
->gc
, None
);
4041 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4042 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4044 /* When the image has a mask, we can expect that at
4045 least part of a mouse highlight or a block cursor will
4046 be visible. If the image doesn't have a mask, make
4047 a block cursor visible by drawing a rectangle around
4048 the image. I believe it's looking better if we do
4049 nothing here for mouse-face. */
4050 if (s
->hl
== DRAW_CURSOR
)
4051 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
4052 s
->img
->width
- 1, s
->img
->height
- 1);
4056 /* Draw a rectangle if image could not be loaded. */
4057 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
4058 s
->img
->width
- 1, s
->img
->height
- 1);
4062 /* Draw part of the background of glyph string S. X, Y, W, and H
4063 give the rectangle to draw. */
4066 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4067 struct glyph_string
*s
;
4072 /* Fill background with a stipple pattern. */
4073 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4074 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4075 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4078 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4082 /* Draw image glyph string S.
4085 s->x +-------------------------
4088 | +-------------------------
4091 | | +-------------------
4097 x_draw_image_glyph_string (s
)
4098 struct glyph_string
*s
;
4101 int box_line_hwidth
= abs (s
->face
->box_line_width
);
4102 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
4104 Pixmap pixmap
= None
;
4106 height
= s
->height
- 2 * box_line_vwidth
;
4108 /* Fill background with face under the image. Do it only if row is
4109 taller than image or if image has a clip mask to reduce
4111 s
->stippled_p
= s
->face
->stipple
!= 0;
4112 if (height
> s
->img
->height
4116 || s
->img
->pixmap
== 0
4117 || s
->width
!= s
->background_width
)
4119 if (box_line_hwidth
&& s
->first_glyph
->left_box_line_p
)
4120 x
= s
->x
+ box_line_hwidth
;
4124 y
= s
->y
+ box_line_vwidth
;
4128 /* Create a pixmap as large as the glyph string. Fill it
4129 with the background color. Copy the image to it, using
4130 its mask. Copy the temporary pixmap to the display. */
4131 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4132 int depth
= DefaultDepthOfScreen (screen
);
4134 /* Create a pixmap as large as the glyph string. */
4135 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4136 s
->background_width
,
4139 /* Don't clip in the following because we're working on the
4141 XSetClipMask (s
->display
, s
->gc
, None
);
4143 /* Fill the pixmap with the background color/stipple. */
4146 /* Fill background with a stipple pattern. */
4147 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4148 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4149 0, 0, s
->background_width
, s
->height
);
4150 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4155 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4157 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4158 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4159 0, 0, s
->background_width
, s
->height
);
4160 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4164 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4166 s
->background_filled_p
= 1;
4169 /* Draw the foreground. */
4172 x_draw_image_foreground_1 (s
, pixmap
);
4173 x_set_glyph_string_clipping (s
);
4174 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
4175 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
4176 XFreePixmap (s
->display
, pixmap
);
4179 x_draw_image_foreground (s
);
4181 /* If we must draw a relief around the image, do it. */
4183 || s
->hl
== DRAW_IMAGE_RAISED
4184 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4185 x_draw_image_relief (s
);
4189 /* Draw stretch glyph string S. */
4192 x_draw_stretch_glyph_string (s
)
4193 struct glyph_string
*s
;
4195 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4196 s
->stippled_p
= s
->face
->stipple
!= 0;
4198 if (s
->hl
== DRAW_CURSOR
4199 && !x_stretch_cursor_p
)
4201 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4202 as wide as the stretch glyph. */
4203 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4206 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4208 /* Clear rest using the GC of the original non-cursor face. */
4209 if (width
< s
->background_width
)
4211 GC gc
= s
->face
->gc
;
4212 int x
= s
->x
+ width
, y
= s
->y
;
4213 int w
= s
->background_width
- width
, h
= s
->height
;
4216 x_get_glyph_string_clip_rect (s
, &r
);
4217 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
4219 if (s
->face
->stipple
)
4221 /* Fill background with a stipple pattern. */
4222 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4223 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4224 XSetFillStyle (s
->display
, gc
, FillSolid
);
4229 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
4230 XSetForeground (s
->display
, gc
, xgcv
.background
);
4231 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4232 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
4237 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4240 s
->background_filled_p
= 1;
4244 /* Draw glyph string S. */
4247 x_draw_glyph_string (s
)
4248 struct glyph_string
*s
;
4250 /* If S draws into the background of its successor, draw the
4251 background of the successor first so that S can draw into it.
4252 This makes S->next use XDrawString instead of XDrawImageString. */
4253 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4255 xassert (s
->next
->img
== NULL
);
4256 x_set_glyph_string_gc (s
->next
);
4257 x_set_glyph_string_clipping (s
->next
);
4258 x_draw_glyph_string_background (s
->next
, 1);
4261 /* Set up S->gc, set clipping and draw S. */
4262 x_set_glyph_string_gc (s
);
4263 x_set_glyph_string_clipping (s
);
4265 switch (s
->first_glyph
->type
)
4268 x_draw_image_glyph_string (s
);
4272 x_draw_stretch_glyph_string (s
);
4276 if (s
->for_overlaps_p
)
4277 s
->background_filled_p
= 1;
4279 x_draw_glyph_string_background (s
, 0);
4280 x_draw_glyph_string_foreground (s
);
4283 case COMPOSITE_GLYPH
:
4284 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4285 s
->background_filled_p
= 1;
4287 x_draw_glyph_string_background (s
, 1);
4288 x_draw_composite_glyph_string_foreground (s
);
4295 if (!s
->for_overlaps_p
)
4297 /* Draw underline. */
4298 if (s
->face
->underline_p
)
4300 unsigned long tem
, h
;
4303 /* Get the underline thickness. Default is 1 pixel. */
4304 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
4307 /* Get the underline position. This is the recommended
4308 vertical offset in pixels from the baseline to the top of
4309 the underline. This is a signed value according to the
4310 specs, and its default is
4312 ROUND ((maximum descent) / 2), with
4313 ROUND(x) = floor (x + 0.5) */
4315 if (XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
4316 y
= s
->ybase
+ (long) tem
;
4317 else if (s
->face
->font
)
4318 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
4322 if (s
->face
->underline_defaulted_p
)
4323 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4324 s
->x
, y
, s
->width
, h
);
4328 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4329 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
4330 XFillRectangle (s
->display
, s
->window
, s
->gc
,
4331 s
->x
, y
, s
->width
, h
);
4332 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4336 /* Draw overline. */
4337 if (s
->face
->overline_p
)
4339 unsigned long dy
= 0, h
= 1;
4341 if (s
->face
->overline_color_defaulted_p
)
4342 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4347 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4348 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4349 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4351 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4355 /* Draw strike-through. */
4356 if (s
->face
->strike_through_p
)
4358 unsigned long h
= 1;
4359 unsigned long dy
= (s
->height
- h
) / 2;
4361 if (s
->face
->strike_through_color_defaulted_p
)
4362 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4367 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4368 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4369 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4371 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4376 if (s
->face
->box
!= FACE_NO_BOX
)
4377 x_draw_glyph_string_box (s
);
4380 /* Reset clipping. */
4381 XSetClipMask (s
->display
, s
->gc
, None
);
4385 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4386 struct face
**, int));
4389 /* Fill glyph string S with composition components specified by S->cmp.
4391 FACES is an array of faces for all components of this composition.
4392 S->gidx is the index of the first component for S.
4393 OVERLAPS_P non-zero means S should draw the foreground only, and
4394 use its physical height for clipping.
4396 Value is the index of a component not in S. */
4399 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4400 struct glyph_string
*s
;
4401 struct face
**faces
;
4408 s
->for_overlaps_p
= overlaps_p
;
4410 s
->face
= faces
[s
->gidx
];
4411 s
->font
= s
->face
->font
;
4412 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4414 /* For all glyphs of this composition, starting at the offset
4415 S->gidx, until we reach the end of the definition or encounter a
4416 glyph that requires the different face, add it to S. */
4418 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4421 /* All glyph strings for the same composition has the same width,
4422 i.e. the width set for the first component of the composition. */
4424 s
->width
= s
->first_glyph
->pixel_width
;
4426 /* If the specified font could not be loaded, use the frame's
4427 default font, but record the fact that we couldn't load it in
4428 the glyph string so that we can draw rectangles for the
4429 characters of the glyph string. */
4430 if (s
->font
== NULL
)
4432 s
->font_not_found_p
= 1;
4433 s
->font
= FRAME_FONT (s
->f
);
4436 /* Adjust base line for subscript/superscript text. */
4437 s
->ybase
+= s
->first_glyph
->voffset
;
4439 xassert (s
->face
&& s
->face
->gc
);
4441 /* This glyph string must always be drawn with 16-bit functions. */
4444 return s
->gidx
+ s
->nchars
;
4448 /* Fill glyph string S from a sequence of character glyphs.
4450 FACE_ID is the face id of the string. START is the index of the
4451 first glyph to consider, END is the index of the last + 1.
4452 OVERLAPS_P non-zero means S should draw the foreground only, and
4453 use its physical height for clipping.
4455 Value is the index of the first glyph not in S. */
4458 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4459 struct glyph_string
*s
;
4461 int start
, end
, overlaps_p
;
4463 struct glyph
*glyph
, *last
;
4465 int glyph_not_available_p
;
4467 xassert (s
->f
== XFRAME (s
->w
->frame
));
4468 xassert (s
->nchars
== 0);
4469 xassert (start
>= 0 && end
> start
);
4471 s
->for_overlaps_p
= overlaps_p
,
4472 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4473 last
= s
->row
->glyphs
[s
->area
] + end
;
4474 voffset
= glyph
->voffset
;
4476 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4479 && glyph
->type
== CHAR_GLYPH
4480 && glyph
->voffset
== voffset
4481 /* Same face id implies same font, nowadays. */
4482 && glyph
->face_id
== face_id
4483 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4487 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4488 s
->char2b
+ s
->nchars
,
4490 s
->two_byte_p
= two_byte_p
;
4492 xassert (s
->nchars
<= end
- start
);
4493 s
->width
+= glyph
->pixel_width
;
4497 s
->font
= s
->face
->font
;
4498 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4500 /* If the specified font could not be loaded, use the frame's font,
4501 but record the fact that we couldn't load it in
4502 S->font_not_found_p so that we can draw rectangles for the
4503 characters of the glyph string. */
4504 if (s
->font
== NULL
|| glyph_not_available_p
)
4506 s
->font_not_found_p
= 1;
4507 s
->font
= FRAME_FONT (s
->f
);
4510 /* Adjust base line for subscript/superscript text. */
4511 s
->ybase
+= voffset
;
4513 xassert (s
->face
&& s
->face
->gc
);
4514 return glyph
- s
->row
->glyphs
[s
->area
];
4518 /* Fill glyph string S from image glyph S->first_glyph. */
4521 x_fill_image_glyph_string (s
)
4522 struct glyph_string
*s
;
4524 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4525 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4527 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4528 s
->font
= s
->face
->font
;
4529 s
->width
= s
->first_glyph
->pixel_width
;
4531 /* Adjust base line for subscript/superscript text. */
4532 s
->ybase
+= s
->first_glyph
->voffset
;
4536 /* Fill glyph string S from a sequence of stretch glyphs.
4538 ROW is the glyph row in which the glyphs are found, AREA is the
4539 area within the row. START is the index of the first glyph to
4540 consider, END is the index of the last + 1.
4542 Value is the index of the first glyph not in S. */
4545 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4546 struct glyph_string
*s
;
4547 struct glyph_row
*row
;
4548 enum glyph_row_area area
;
4551 struct glyph
*glyph
, *last
;
4552 int voffset
, face_id
;
4554 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4556 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4557 last
= s
->row
->glyphs
[s
->area
] + end
;
4558 face_id
= glyph
->face_id
;
4559 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4560 s
->font
= s
->face
->font
;
4561 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4562 s
->width
= glyph
->pixel_width
;
4563 voffset
= glyph
->voffset
;
4567 && glyph
->type
== STRETCH_GLYPH
4568 && glyph
->voffset
== voffset
4569 && glyph
->face_id
== face_id
);
4571 s
->width
+= glyph
->pixel_width
;
4573 /* Adjust base line for subscript/superscript text. */
4574 s
->ybase
+= voffset
;
4576 xassert (s
->face
&& s
->face
->gc
);
4577 return glyph
- s
->row
->glyphs
[s
->area
];
4581 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4582 of XChar2b structures for S; it can't be allocated in
4583 x_init_glyph_string because it must be allocated via `alloca'. W
4584 is the window on which S is drawn. ROW and AREA are the glyph row
4585 and area within the row from which S is constructed. START is the
4586 index of the first glyph structure covered by S. HL is a
4587 face-override for drawing S. */
4590 x_init_glyph_string (s
, char2b
, w
, row
, area
, start
, hl
)
4591 struct glyph_string
*s
;
4594 struct glyph_row
*row
;
4595 enum glyph_row_area area
;
4597 enum draw_glyphs_face hl
;
4599 bzero (s
, sizeof *s
);
4601 s
->f
= XFRAME (w
->frame
);
4602 s
->display
= FRAME_X_DISPLAY (s
->f
);
4603 s
->window
= FRAME_X_WINDOW (s
->f
);
4608 s
->first_glyph
= row
->glyphs
[area
] + start
;
4609 s
->height
= row
->height
;
4610 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4612 /* Display the internal border below the tool-bar window. */
4613 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4614 s
->y
-= s
->f
->output_data
.x
->internal_border_width
;
4616 s
->ybase
= s
->y
+ row
->ascent
;
4620 /* Set background width of glyph string S. START is the index of the
4621 first glyph following S. LAST_X is the right-most x-position + 1
4622 in the drawing area. */
4625 x_set_glyph_string_background_width (s
, start
, last_x
)
4626 struct glyph_string
*s
;
4630 /* If the face of this glyph string has to be drawn to the end of
4631 the drawing area, set S->extends_to_end_of_line_p. */
4632 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4634 if (start
== s
->row
->used
[s
->area
]
4635 && s
->hl
== DRAW_NORMAL_TEXT
4636 && s
->area
== TEXT_AREA
4637 && (s
->row
->fill_line_p
4638 || s
->face
->background
!= default_face
->background
4639 || s
->face
->stipple
!= default_face
->stipple
))
4640 s
->extends_to_end_of_line_p
= 1;
4642 /* If S extends its face to the end of the line, set its
4643 background_width to the distance to the right edge of the drawing
4645 if (s
->extends_to_end_of_line_p
)
4646 s
->background_width
= last_x
- s
->x
+ 1;
4648 s
->background_width
= s
->width
;
4652 /* Add a glyph string for a stretch glyph to the list of strings
4653 between HEAD and TAIL. START is the index of the stretch glyph in
4654 row area AREA of glyph row ROW. END is the index of the last glyph
4655 in that glyph row area. X is the current output position assigned
4656 to the new glyph string constructed. HL overrides that face of the
4657 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4658 is the right-most x-position of the drawing area. */
4660 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4661 and below -- keep them on one line. */
4662 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4665 s = (struct glyph_string *) alloca (sizeof *s); \
4666 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4667 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4668 x_append_glyph_string (&HEAD, &TAIL, s); \
4674 /* Add a glyph string for an image glyph to the list of strings
4675 between HEAD and TAIL. START is the index of the image glyph in
4676 row area AREA of glyph row ROW. END is the index of the last glyph
4677 in that glyph row area. X is the current output position assigned
4678 to the new glyph string constructed. HL overrides that face of the
4679 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4680 is the right-most x-position of the drawing area. */
4682 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4685 s = (struct glyph_string *) alloca (sizeof *s); \
4686 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4687 x_fill_image_glyph_string (s); \
4688 x_append_glyph_string (&HEAD, &TAIL, s); \
4695 /* Add a glyph string for a sequence of character glyphs to the list
4696 of strings between HEAD and TAIL. START is the index of the first
4697 glyph in row area AREA of glyph row ROW that is part of the new
4698 glyph string. END is the index of the last glyph in that glyph row
4699 area. X is the current output position assigned to the new glyph
4700 string constructed. HL overrides that face of the glyph; e.g. it
4701 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4702 right-most x-position of the drawing area. */
4704 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4710 c = (ROW)->glyphs[AREA][START].u.ch; \
4711 face_id = (ROW)->glyphs[AREA][START].face_id; \
4713 s = (struct glyph_string *) alloca (sizeof *s); \
4714 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4715 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4716 x_append_glyph_string (&HEAD, &TAIL, s); \
4718 START = x_fill_glyph_string (s, face_id, START, END, \
4724 /* Add a glyph string for a composite sequence to the list of strings
4725 between HEAD and TAIL. START is the index of the first glyph in
4726 row area AREA of glyph row ROW that is part of the new glyph
4727 string. END is the index of the last glyph in that glyph row area.
4728 X is the current output position assigned to the new glyph string
4729 constructed. HL overrides that face of the glyph; e.g. it is
4730 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4731 x-position of the drawing area. */
4733 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4735 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4736 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4737 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4738 struct composition *cmp = composition_table[cmp_id]; \
4739 int glyph_len = cmp->glyph_len; \
4741 struct face **faces; \
4742 struct glyph_string *first_s = NULL; \
4745 base_face = base_face->ascii_face; \
4746 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4747 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4748 /* At first, fill in `char2b' and `faces'. */ \
4749 for (n = 0; n < glyph_len; n++) \
4751 int c = COMPOSITION_GLYPH (cmp, n); \
4752 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4753 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4754 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4755 this_face_id, char2b + n, 1); \
4758 /* Make glyph_strings for each glyph sequence that is drawable by \
4759 the same face, and append them to HEAD/TAIL. */ \
4760 for (n = 0; n < cmp->glyph_len;) \
4762 s = (struct glyph_string *) alloca (sizeof *s); \
4763 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
4764 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4772 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4780 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4781 of AREA of glyph row ROW on window W between indices START and END.
4782 HL overrides the face for drawing glyph strings, e.g. it is
4783 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4784 x-positions of the drawing area.
4786 This is an ugly monster macro construct because we must use alloca
4787 to allocate glyph strings (because x_draw_glyphs can be called
4790 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4793 HEAD = TAIL = NULL; \
4794 while (START < END) \
4796 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4797 switch (first_glyph->type) \
4800 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
4801 TAIL, HL, X, LAST_X, \
4805 case COMPOSITE_GLYPH: \
4806 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
4807 HEAD, TAIL, HL, X, LAST_X,\
4811 case STRETCH_GLYPH: \
4812 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
4813 HEAD, TAIL, HL, X, LAST_X); \
4817 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
4818 TAIL, HL, X, LAST_X); \
4825 x_set_glyph_string_background_width (s, START, LAST_X); \
4832 /* Draw glyphs between START and END in AREA of ROW on window W,
4833 starting at x-position X. X is relative to AREA in W. HL is a
4834 face-override with the following meaning:
4836 DRAW_NORMAL_TEXT draw normally
4837 DRAW_CURSOR draw in cursor face
4838 DRAW_MOUSE_FACE draw in mouse face.
4839 DRAW_INVERSE_VIDEO draw in mode line face
4840 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
4841 DRAW_IMAGE_RAISED draw an image with a raised relief around it
4843 If REAL_START is non-null, return in *REAL_START the real starting
4844 position for display. This can be different from START in case
4845 overlapping glyphs must be displayed. If REAL_END is non-null,
4846 return in *REAL_END the real end position for display. This can be
4847 different from END in case overlapping glyphs must be displayed.
4849 If OVERLAPS_P is non-zero, draw only the foreground of characters
4850 and clip to the physical height of ROW.
4852 Value is the x-position reached, relative to AREA of W. */
4855 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, real_start
, real_end
,
4859 struct glyph_row
*row
;
4860 enum glyph_row_area area
;
4862 enum draw_glyphs_face hl
;
4863 int *real_start
, *real_end
;
4866 struct glyph_string
*head
, *tail
;
4867 struct glyph_string
*s
;
4868 int last_x
, area_width
;
4872 /* Let's rather be paranoid than getting a SEGV. */
4873 end
= min (end
, row
->used
[area
]);
4874 start
= max (0, start
);
4875 start
= min (end
, start
);
4877 *real_start
= start
;
4881 /* Translate X to frame coordinates. Set last_x to the right
4882 end of the drawing area. */
4883 if (row
->full_width_p
)
4885 /* X is relative to the left edge of W, without scroll bars
4887 struct frame
*f
= XFRAME (w
->frame
);
4888 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
4889 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
4892 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4893 last_x
= window_left_x
+ area_width
;
4895 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4897 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4898 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4904 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
4905 last_x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
4909 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
4910 area_width
= window_box_width (w
, area
);
4911 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
4914 /* Build a doubly-linked list of glyph_string structures between
4915 head and tail from what we have to draw. Note that the macro
4916 BUILD_GLYPH_STRINGS will modify its start parameter. That's
4917 the reason we use a separate variable `i'. */
4919 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
4922 x_reached
= tail
->x
+ tail
->background_width
;
4926 /* If there are any glyphs with lbearing < 0 or rbearing > width in
4927 the row, redraw some glyphs in front or following the glyph
4928 strings built above. */
4929 if (head
&& !overlaps_p
&& row
->contains_overlapping_glyphs_p
)
4932 struct glyph_string
*h
, *t
;
4934 /* Compute overhangs for all glyph strings. */
4935 for (s
= head
; s
; s
= s
->next
)
4936 x_compute_glyph_string_overhangs (s
);
4938 /* Prepend glyph strings for glyphs in front of the first glyph
4939 string that are overwritten because of the first glyph
4940 string's left overhang. The background of all strings
4941 prepended must be drawn because the first glyph string
4943 i
= x_left_overwritten (head
);
4947 BUILD_GLYPH_STRINGS (w
, row
, area
, j
, start
, h
, t
,
4948 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4952 *real_start
= start
;
4953 x_compute_overhangs_and_x (t
, head
->x
, 1);
4954 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4957 /* Prepend glyph strings for glyphs in front of the first glyph
4958 string that overwrite that glyph string because of their
4959 right overhang. For these strings, only the foreground must
4960 be drawn, because it draws over the glyph string at `head'.
4961 The background must not be drawn because this would overwrite
4962 right overhangs of preceding glyphs for which no glyph
4964 i
= x_left_overwriting (head
);
4967 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, start
, h
, t
,
4968 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4970 for (s
= h
; s
; s
= s
->next
)
4971 s
->background_filled_p
= 1;
4974 x_compute_overhangs_and_x (t
, head
->x
, 1);
4975 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4978 /* Append glyphs strings for glyphs following the last glyph
4979 string tail that are overwritten by tail. The background of
4980 these strings has to be drawn because tail's foreground draws
4982 i
= x_right_overwritten (tail
);
4985 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
4986 DRAW_NORMAL_TEXT
, x
, last_x
,
4988 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4989 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4994 /* Append glyph strings for glyphs following the last glyph
4995 string tail that overwrite tail. The foreground of such
4996 glyphs has to be drawn because it writes into the background
4997 of tail. The background must not be drawn because it could
4998 paint over the foreground of following glyphs. */
4999 i
= x_right_overwriting (tail
);
5002 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5003 DRAW_NORMAL_TEXT
, x
, last_x
,
5005 for (s
= h
; s
; s
= s
->next
)
5006 s
->background_filled_p
= 1;
5007 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5008 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5014 /* Draw all strings. */
5015 for (s
= head
; s
; s
= s
->next
)
5016 x_draw_glyph_string (s
);
5018 /* Value is the x-position up to which drawn, relative to AREA of W.
5019 This doesn't include parts drawn because of overhangs. */
5020 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
5021 if (!row
->full_width_p
)
5023 if (area
> LEFT_MARGIN_AREA
)
5024 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5025 if (area
> TEXT_AREA
)
5026 x_reached
-= window_box_width (w
, TEXT_AREA
);
5033 /* Fix the display of area AREA of overlapping row ROW in window W. */
5036 x_fix_overlapping_area (w
, row
, area
)
5038 struct glyph_row
*row
;
5039 enum glyph_row_area area
;
5045 if (area
== LEFT_MARGIN_AREA
)
5047 else if (area
== TEXT_AREA
)
5048 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5050 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5051 + window_box_width (w
, TEXT_AREA
));
5053 for (i
= 0; i
< row
->used
[area
];)
5055 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
5057 int start
= i
, start_x
= x
;
5061 x
+= row
->glyphs
[area
][i
].pixel_width
;
5064 while (i
< row
->used
[area
]
5065 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5067 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5069 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5074 x
+= row
->glyphs
[area
][i
].pixel_width
;
5083 /* Output LEN glyphs starting at START at the nominal cursor position.
5084 Advance the nominal cursor over the text. The global variable
5085 updated_window contains the window being updated, updated_row is
5086 the glyph row being updated, and updated_area is the area of that
5087 row being updated. */
5090 x_write_glyphs (start
, len
)
5091 struct glyph
*start
;
5094 int x
, hpos
, real_start
, real_end
;
5096 xassert (updated_window
&& updated_row
);
5101 hpos
= start
- updated_row
->glyphs
[updated_area
];
5102 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5103 updated_row
, updated_area
,
5105 (updated_row
->inverse_p
5106 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5107 &real_start
, &real_end
, 0);
5109 /* If we drew over the cursor, note that it is not visible any more. */
5110 note_overwritten_text_cursor (updated_window
, real_start
,
5111 real_end
- real_start
);
5115 /* Advance the output cursor. */
5116 output_cursor
.hpos
+= len
;
5117 output_cursor
.x
= x
;
5121 /* Insert LEN glyphs from START at the nominal cursor position. */
5124 x_insert_glyphs (start
, len
)
5125 struct glyph
*start
;
5130 int line_height
, shift_by_width
, shifted_region_width
;
5131 struct glyph_row
*row
;
5132 struct glyph
*glyph
;
5133 int frame_x
, frame_y
, hpos
, real_start
, real_end
;
5135 xassert (updated_window
&& updated_row
);
5138 f
= XFRAME (WINDOW_FRAME (w
));
5140 /* Get the height of the line we are in. */
5142 line_height
= row
->height
;
5144 /* Get the width of the glyphs to insert. */
5146 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5147 shift_by_width
+= glyph
->pixel_width
;
5149 /* Get the width of the region to shift right. */
5150 shifted_region_width
= (window_box_width (w
, updated_area
)
5155 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
5156 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5157 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5158 f
->output_data
.x
->normal_gc
,
5160 shifted_region_width
, line_height
,
5161 frame_x
+ shift_by_width
, frame_y
);
5163 /* Write the glyphs. */
5164 hpos
= start
- row
->glyphs
[updated_area
];
5165 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5166 DRAW_NORMAL_TEXT
, &real_start
, &real_end
, 0);
5167 note_overwritten_text_cursor (w
, real_start
, real_end
- real_start
);
5169 /* Advance the output cursor. */
5170 output_cursor
.hpos
+= len
;
5171 output_cursor
.x
+= shift_by_width
;
5176 /* Delete N glyphs at the nominal cursor position. Not implemented
5187 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
5188 If they are <= 0, this is probably an error. */
5191 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
5198 xassert (width
> 0 && height
> 0);
5199 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
5203 /* Erase the current text line from the nominal cursor position
5204 (inclusive) to pixel column TO_X (exclusive). The idea is that
5205 everything from TO_X onward is already erased.
5207 TO_X is a pixel position relative to updated_area of
5208 updated_window. TO_X == -1 means clear to the end of this area. */
5211 x_clear_end_of_line (to_x
)
5215 struct window
*w
= updated_window
;
5216 int max_x
, min_y
, max_y
;
5217 int from_x
, from_y
, to_y
;
5219 xassert (updated_window
&& updated_row
);
5220 f
= XFRAME (w
->frame
);
5222 if (updated_row
->full_width_p
)
5224 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5225 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5226 && !w
->pseudo_window_p
)
5227 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5230 max_x
= window_box_width (w
, updated_area
);
5231 max_y
= window_text_bottom_y (w
);
5233 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5234 of window. For TO_X > 0, truncate to end of drawing area. */
5240 to_x
= min (to_x
, max_x
);
5242 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5244 /* Notice if the cursor will be cleared by this operation. */
5245 if (!updated_row
->full_width_p
)
5246 note_overwritten_text_cursor (w
, output_cursor
.hpos
, -1);
5248 from_x
= output_cursor
.x
;
5250 /* Translate to frame coordinates. */
5251 if (updated_row
->full_width_p
)
5253 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5254 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5258 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5259 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5262 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5263 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5264 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5266 /* Prevent inadvertently clearing to end of the X window. */
5267 if (to_x
> from_x
&& to_y
> from_y
)
5270 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5271 from_x
, from_y
, to_x
- from_x
, to_y
- from_y
,
5278 /* Clear entire frame. If updating_frame is non-null, clear that
5279 frame. Otherwise clear the selected frame. */
5289 f
= SELECTED_FRAME ();
5291 /* Clearing the frame will erase any cursor, so mark them all as no
5293 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5294 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5295 output_cursor
.x
= -1;
5297 /* We don't set the output cursor here because there will always
5298 follow an explicit cursor_to. */
5300 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
5302 /* We have to clear the scroll bars, too. If we have changed
5303 colors or something like that, then they should be notified. */
5304 x_scroll_bar_clear (f
);
5306 XFlush (FRAME_X_DISPLAY (f
));
5312 /* Invert the middle quarter of the frame for .15 sec. */
5314 /* We use the select system call to do the waiting, so we have to make
5315 sure it's available. If it isn't, we just won't do visual bells. */
5317 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5320 /* Subtract the `struct timeval' values X and Y, storing the result in
5321 *RESULT. Return 1 if the difference is negative, otherwise 0. */
5324 timeval_subtract (result
, x
, y
)
5325 struct timeval
*result
, x
, y
;
5327 /* Perform the carry for the later subtraction by updating y. This
5328 is safer because on some systems the tv_sec member is unsigned. */
5329 if (x
.tv_usec
< y
.tv_usec
)
5331 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
5332 y
.tv_usec
-= 1000000 * nsec
;
5336 if (x
.tv_usec
- y
.tv_usec
> 1000000)
5338 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
5339 y
.tv_usec
+= 1000000 * nsec
;
5343 /* Compute the time remaining to wait. tv_usec is certainly
5345 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
5346 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
5348 /* Return indication of whether the result should be considered
5350 return x
.tv_sec
< y
.tv_sec
;
5362 /* Create a GC that will use the GXxor function to flip foreground
5363 pixels into background pixels. */
5367 values
.function
= GXxor
;
5368 values
.foreground
= (f
->output_data
.x
->foreground_pixel
5369 ^ f
->output_data
.x
->background_pixel
);
5371 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5372 GCFunction
| GCForeground
, &values
);
5376 /* Get the height not including a menu bar widget. */
5377 int height
= CHAR_TO_PIXEL_HEIGHT (f
, FRAME_HEIGHT (f
));
5378 /* Height of each line to flash. */
5379 int flash_height
= FRAME_LINE_HEIGHT (f
);
5380 /* These will be the left and right margins of the rectangles. */
5381 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
5382 int flash_right
= PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
5386 /* Don't flash the area between a scroll bar and the frame
5387 edge it is next to. */
5388 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
5390 case vertical_scroll_bar_left
:
5391 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5394 case vertical_scroll_bar_right
:
5395 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5402 width
= flash_right
- flash_left
;
5404 /* If window is tall, flash top and bottom line. */
5405 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5407 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5409 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5410 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5411 width
, flash_height
);
5412 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5414 (height
- flash_height
5415 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5416 width
, flash_height
);
5419 /* If it is short, flash it all. */
5420 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5421 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5422 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5427 struct timeval wakeup
;
5429 EMACS_GET_TIME (wakeup
);
5431 /* Compute time to wait until, propagating carry from usecs. */
5432 wakeup
.tv_usec
+= 150000;
5433 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
5434 wakeup
.tv_usec
%= 1000000;
5436 /* Keep waiting until past the time wakeup. */
5439 struct timeval timeout
;
5441 EMACS_GET_TIME (timeout
);
5443 /* In effect, timeout = wakeup - timeout.
5444 Break if result would be negative. */
5445 if (timeval_subtract (&timeout
, wakeup
, timeout
))
5448 /* Try to wait that long--but we might wake up sooner. */
5449 select (0, NULL
, NULL
, NULL
, &timeout
);
5453 /* If window is tall, flash top and bottom line. */
5454 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5456 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5458 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5459 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5460 width
, flash_height
);
5461 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5463 (height
- flash_height
5464 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5465 width
, flash_height
);
5468 /* If it is short, flash it all. */
5469 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5470 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5471 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5473 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5481 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5484 /* Make audible bell. */
5489 struct frame
*f
= SELECTED_FRAME ();
5491 if (FRAME_X_DISPLAY (f
))
5493 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5500 XBell (FRAME_X_DISPLAY (f
), 0);
5501 XFlush (FRAME_X_DISPLAY (f
));
5508 /* Specify how many text lines, from the top of the window,
5509 should be affected by insert-lines and delete-lines operations.
5510 This, and those operations, are used only within an update
5511 that is bounded by calls to x_update_begin and x_update_end. */
5514 XTset_terminal_window (n
)
5517 /* This function intentionally left blank. */
5522 /***********************************************************************
5524 ***********************************************************************/
5526 /* Perform an insert-lines or delete-lines operation, inserting N
5527 lines or deleting -N lines at vertical position VPOS. */
5530 x_ins_del_lines (vpos
, n
)
5537 /* Scroll part of the display as described by RUN. */
5540 x_scroll_run (w
, run
)
5544 struct frame
*f
= XFRAME (w
->frame
);
5545 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5547 /* Get frame-relative bounding box of the text display area of W,
5548 without mode lines. Include in this box the flags areas to the
5549 left and right of W. */
5550 window_box (w
, -1, &x
, &y
, &width
, &height
);
5551 width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
5552 x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
5554 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5555 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5556 bottom_y
= y
+ height
;
5560 /* Scrolling up. Make sure we don't copy part of the mode
5561 line at the bottom. */
5562 if (from_y
+ run
->height
> bottom_y
)
5563 height
= bottom_y
- from_y
;
5565 height
= run
->height
;
5569 /* Scolling down. Make sure we don't copy over the mode line.
5571 if (to_y
+ run
->height
> bottom_y
)
5572 height
= bottom_y
- to_y
;
5574 height
= run
->height
;
5579 /* Cursor off. Will be switched on again in x_update_window_end. */
5583 XCopyArea (FRAME_X_DISPLAY (f
),
5584 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5585 f
->output_data
.x
->normal_gc
,
5595 /***********************************************************************
5597 ***********************************************************************/
5599 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5600 corner of the exposed rectangle. W and H are width and height of
5601 the exposed area. All are pixel values. W or H zero means redraw
5602 the entire frame. */
5605 expose_frame (f
, x
, y
, w
, h
)
5611 TRACE ((stderr
, "expose_frame "));
5613 /* No need to redraw if frame will be redrawn soon. */
5614 if (FRAME_GARBAGED_P (f
))
5616 TRACE ((stderr
, " garbaged\n"));
5620 /* If basic faces haven't been realized yet, there is no point in
5621 trying to redraw anything. This can happen when we get an expose
5622 event while Emacs is starting, e.g. by moving another window. */
5623 if (FRAME_FACE_CACHE (f
) == NULL
5624 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5626 TRACE ((stderr
, " no faces\n"));
5630 if (w
== 0 || h
== 0)
5633 r
.width
= CANON_X_UNIT (f
) * f
->width
;
5634 r
.height
= CANON_Y_UNIT (f
) * f
->height
;
5644 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
5645 expose_window_tree (XWINDOW (f
->root_window
), &r
);
5647 if (WINDOWP (f
->tool_bar_window
))
5649 struct window
*w
= XWINDOW (f
->tool_bar_window
);
5650 XRectangle window_rect
;
5651 XRectangle intersection_rect
;
5652 int window_x
, window_y
, window_width
, window_height
;
5655 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5656 window_rect
.x
= window_x
;
5657 window_rect
.y
= window_y
;
5658 window_rect
.width
= window_width
;
5659 window_rect
.height
= window_height
;
5661 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5662 expose_window (w
, &intersection_rect
);
5665 #ifndef USE_X_TOOLKIT
5666 if (WINDOWP (f
->menu_bar_window
))
5668 struct window
*w
= XWINDOW (f
->menu_bar_window
);
5669 XRectangle window_rect
;
5670 XRectangle intersection_rect
;
5671 int window_x
, window_y
, window_width
, window_height
;
5674 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5675 window_rect
.x
= window_x
;
5676 window_rect
.y
= window_y
;
5677 window_rect
.width
= window_width
;
5678 window_rect
.height
= window_height
;
5680 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5681 expose_window (w
, &intersection_rect
);
5683 #endif /* not USE_X_TOOLKIT */
5687 /* Redraw (parts) of all windows in the window tree rooted at W that
5688 intersect R. R contains frame pixel coordinates. */
5691 expose_window_tree (w
, r
)
5697 if (!NILP (w
->hchild
))
5698 expose_window_tree (XWINDOW (w
->hchild
), r
);
5699 else if (!NILP (w
->vchild
))
5700 expose_window_tree (XWINDOW (w
->vchild
), r
);
5703 XRectangle window_rect
;
5704 XRectangle intersection_rect
;
5705 struct frame
*f
= XFRAME (w
->frame
);
5706 int window_x
, window_y
, window_width
, window_height
;
5708 /* Frame-relative pixel rectangle of W. */
5709 window_box (w
, -1, &window_x
, &window_y
, &window_width
,
5713 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
5714 - FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5715 window_rect
.y
= window_y
;
5718 + FRAME_X_FLAGS_AREA_WIDTH (f
)
5719 + FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5721 = window_height
+ CURRENT_MODE_LINE_HEIGHT (w
);
5723 if (x_intersect_rectangles (r
, &window_rect
, &intersection_rect
))
5724 expose_window (w
, &intersection_rect
);
5727 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5732 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5733 which intersects rectangle R. R is in window-relative coordinates. */
5736 expose_area (w
, row
, r
, area
)
5738 struct glyph_row
*row
;
5740 enum glyph_row_area area
;
5742 struct glyph
*first
= row
->glyphs
[area
];
5743 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5745 int first_x
, start_x
, x
;
5747 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5748 /* If row extends face to end of line write the whole line. */
5749 x_draw_glyphs (w
, 0, row
, area
,
5751 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5755 /* Set START_X to the window-relative start position for drawing glyphs of
5756 AREA. The first glyph of the text area can be partially visible.
5757 The first glyphs of other areas cannot. */
5758 if (area
== LEFT_MARGIN_AREA
)
5760 else if (area
== TEXT_AREA
)
5761 start_x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5763 start_x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5764 + window_box_width (w
, TEXT_AREA
));
5767 /* Find the first glyph that must be redrawn. */
5769 && x
+ first
->pixel_width
< r
->x
)
5771 x
+= first
->pixel_width
;
5775 /* Find the last one. */
5779 && x
< r
->x
+ r
->width
)
5781 x
+= last
->pixel_width
;
5787 x_draw_glyphs (w
, first_x
- start_x
, row
, area
,
5788 first
- row
->glyphs
[area
],
5789 last
- row
->glyphs
[area
],
5790 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5796 /* Redraw the parts of the glyph row ROW on window W intersecting
5797 rectangle R. R is in window-relative coordinates. */
5800 expose_line (w
, row
, r
)
5802 struct glyph_row
*row
;
5805 xassert (row
->enabled_p
);
5807 if (row
->mode_line_p
|| w
->pseudo_window_p
)
5808 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
5809 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5813 if (row
->used
[LEFT_MARGIN_AREA
])
5814 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
5815 if (row
->used
[TEXT_AREA
])
5816 expose_area (w
, row
, r
, TEXT_AREA
);
5817 if (row
->used
[RIGHT_MARGIN_AREA
])
5818 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
5819 x_draw_row_bitmaps (w
, row
);
5824 /* Return non-zero if W's cursor intersects rectangle R. */
5827 x_phys_cursor_in_rect_p (w
, r
)
5831 XRectangle cr
, result
;
5832 struct glyph
*cursor_glyph
;
5834 cursor_glyph
= get_phys_cursor_glyph (w
);
5837 cr
.x
= w
->phys_cursor
.x
;
5838 cr
.y
= w
->phys_cursor
.y
;
5839 cr
.width
= cursor_glyph
->pixel_width
;
5840 cr
.height
= w
->phys_cursor_height
;
5841 return x_intersect_rectangles (&cr
, r
, &result
);
5848 /* Redraw a rectangle of window W. R is a rectangle in window
5849 relative coordinates. Call this function with input blocked. */
5852 expose_window (w
, r
)
5856 struct glyph_row
*row
;
5858 int yb
= window_text_bottom_y (w
);
5859 int cursor_cleared_p
;
5861 /* If window is not yet fully initialized, do nothing. This can
5862 happen when toolkit scroll bars are used and a window is split.
5863 Reconfiguring the scroll bar will generate an expose for a newly
5865 if (w
->current_matrix
== NULL
|| w
== updated_window
)
5868 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
5869 r
->x
, r
->y
, r
->width
, r
->height
));
5871 /* Convert to window coordinates. */
5872 r
->x
= FRAME_TO_WINDOW_PIXEL_X (w
, r
->x
);
5873 r
->y
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
->y
);
5875 /* Turn off the cursor. */
5876 if (!w
->pseudo_window_p
5877 && x_phys_cursor_in_rect_p (w
, r
))
5880 cursor_cleared_p
= 1;
5883 cursor_cleared_p
= 0;
5885 /* Find the first row intersecting the rectangle R. */
5886 row
= w
->current_matrix
->rows
;
5888 while (row
->enabled_p
5890 && y
+ row
->height
< r
->y
)
5896 /* Display the text in the rectangle, one text line at a time. */
5897 while (row
->enabled_p
5899 && y
< r
->y
+ r
->height
)
5901 expose_line (w
, row
, r
);
5906 /* Display the mode line if there is one. */
5907 if (WINDOW_WANTS_MODELINE_P (w
)
5908 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
5910 && row
->y
< r
->y
+ r
->height
)
5911 expose_line (w
, row
, r
);
5913 if (!w
->pseudo_window_p
)
5915 /* Draw border between windows. */
5916 x_draw_vertical_border (w
);
5918 /* Turn the cursor on again. */
5919 if (cursor_cleared_p
)
5920 x_update_window_cursor (w
, 1);
5925 /* Determine the intersection of two rectangles R1 and R2. Return
5926 the intersection in *RESULT. Value is non-zero if RESULT is not
5930 x_intersect_rectangles (r1
, r2
, result
)
5931 XRectangle
*r1
, *r2
, *result
;
5933 XRectangle
*left
, *right
;
5934 XRectangle
*upper
, *lower
;
5935 int intersection_p
= 0;
5937 /* Rearrange so that R1 is the left-most rectangle. */
5939 left
= r1
, right
= r2
;
5941 left
= r2
, right
= r1
;
5943 /* X0 of the intersection is right.x0, if this is inside R1,
5944 otherwise there is no intersection. */
5945 if (right
->x
<= left
->x
+ left
->width
)
5947 result
->x
= right
->x
;
5949 /* The right end of the intersection is the minimum of the
5950 the right ends of left and right. */
5951 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
5954 /* Same game for Y. */
5956 upper
= r1
, lower
= r2
;
5958 upper
= r2
, lower
= r1
;
5960 /* The upper end of the intersection is lower.y0, if this is inside
5961 of upper. Otherwise, there is no intersection. */
5962 if (lower
->y
<= upper
->y
+ upper
->height
)
5964 result
->y
= lower
->y
;
5966 /* The lower end of the intersection is the minimum of the lower
5967 ends of upper and lower. */
5968 result
->height
= (min (lower
->y
+ lower
->height
,
5969 upper
->y
+ upper
->height
)
5975 return intersection_p
;
5986 /* We used to only do this if Vx_no_window_manager was non-nil, but
5987 the ICCCM (section 4.1.6) says that the window's border pixmap
5988 and border pixel are window attributes which are "private to the
5989 client", so we can always change it to whatever we want. */
5991 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5992 f
->output_data
.x
->border_pixel
);
5994 x_update_cursor (f
, 1);
5998 frame_unhighlight (f
)
6001 /* We used to only do this if Vx_no_window_manager was non-nil, but
6002 the ICCCM (section 4.1.6) says that the window's border pixmap
6003 and border pixel are window attributes which are "private to the
6004 client", so we can always change it to whatever we want. */
6006 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6007 f
->output_data
.x
->border_tile
);
6009 x_update_cursor (f
, 1);
6012 /* The focus has changed. Update the frames as necessary to reflect
6013 the new situation. Note that we can't change the selected frame
6014 here, because the Lisp code we are interrupting might become confused.
6015 Each event gets marked with the frame in which it occurred, so the
6016 Lisp code can tell when the switch took place by examining the events. */
6019 x_new_focus_frame (dpyinfo
, frame
)
6020 struct x_display_info
*dpyinfo
;
6021 struct frame
*frame
;
6023 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
6025 if (frame
!= dpyinfo
->x_focus_frame
)
6027 /* Set this before calling other routines, so that they see
6028 the correct value of x_focus_frame. */
6029 dpyinfo
->x_focus_frame
= frame
;
6031 if (old_focus
&& old_focus
->auto_lower
)
6032 x_lower_frame (old_focus
);
6035 selected_frame
= frame
;
6036 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
6038 Fselect_window (selected_frame
->selected_window
);
6039 choose_minibuf_frame ();
6042 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
6043 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
6045 pending_autoraise_frame
= 0;
6048 x_frame_rehighlight (dpyinfo
);
6051 /* Handle an event saying the mouse has moved out of an Emacs frame. */
6054 x_mouse_leave (dpyinfo
)
6055 struct x_display_info
*dpyinfo
;
6057 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
6060 /* The focus has changed, or we have redirected a frame's focus to
6061 another frame (this happens when a frame uses a surrogate
6062 mini-buffer frame). Shift the highlight as appropriate.
6064 The FRAME argument doesn't necessarily have anything to do with which
6065 frame is being highlighted or un-highlighted; we only use it to find
6066 the appropriate X display info. */
6069 XTframe_rehighlight (frame
)
6070 struct frame
*frame
;
6072 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
6076 x_frame_rehighlight (dpyinfo
)
6077 struct x_display_info
*dpyinfo
;
6079 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
6081 if (dpyinfo
->x_focus_frame
)
6083 dpyinfo
->x_highlight_frame
6084 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
6085 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
6086 : dpyinfo
->x_focus_frame
);
6087 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
6089 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
6090 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
6094 dpyinfo
->x_highlight_frame
= 0;
6096 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
6099 frame_unhighlight (old_highlight
);
6100 if (dpyinfo
->x_highlight_frame
)
6101 frame_highlight (dpyinfo
->x_highlight_frame
);
6107 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
6109 /* Initialize mode_switch_bit and modifier_meaning. */
6111 x_find_modifier_meanings (dpyinfo
)
6112 struct x_display_info
*dpyinfo
;
6114 int min_code
, max_code
;
6117 XModifierKeymap
*mods
;
6119 dpyinfo
->meta_mod_mask
= 0;
6120 dpyinfo
->shift_lock_mask
= 0;
6121 dpyinfo
->alt_mod_mask
= 0;
6122 dpyinfo
->super_mod_mask
= 0;
6123 dpyinfo
->hyper_mod_mask
= 0;
6126 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
6128 min_code
= dpyinfo
->display
->min_keycode
;
6129 max_code
= dpyinfo
->display
->max_keycode
;
6132 syms
= XGetKeyboardMapping (dpyinfo
->display
,
6133 min_code
, max_code
- min_code
+ 1,
6135 mods
= XGetModifierMapping (dpyinfo
->display
);
6137 /* Scan the modifier table to see which modifier bits the Meta and
6138 Alt keysyms are on. */
6140 int row
, col
; /* The row and column in the modifier table. */
6142 for (row
= 3; row
< 8; row
++)
6143 for (col
= 0; col
< mods
->max_keypermod
; col
++)
6146 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
6148 /* Zeroes are used for filler. Skip them. */
6152 /* Are any of this keycode's keysyms a meta key? */
6156 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
6158 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
6164 dpyinfo
->meta_mod_mask
|= (1 << row
);
6169 dpyinfo
->alt_mod_mask
|= (1 << row
);
6174 dpyinfo
->hyper_mod_mask
|= (1 << row
);
6179 dpyinfo
->super_mod_mask
|= (1 << row
);
6183 /* Ignore this if it's not on the lock modifier. */
6184 if ((1 << row
) == LockMask
)
6185 dpyinfo
->shift_lock_mask
= LockMask
;
6193 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
6194 if (! dpyinfo
->meta_mod_mask
)
6196 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
6197 dpyinfo
->alt_mod_mask
= 0;
6200 /* If some keys are both alt and meta,
6201 make them just meta, not alt. */
6202 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
6204 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
6207 XFree ((char *) syms
);
6208 XFreeModifiermap (mods
);
6211 /* Convert between the modifier bits X uses and the modifier bits
6215 x_x_to_emacs_modifiers (dpyinfo
, state
)
6216 struct x_display_info
*dpyinfo
;
6219 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
6220 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
6221 | ((state
& dpyinfo
->meta_mod_mask
) ? meta_modifier
: 0)
6222 | ((state
& dpyinfo
->alt_mod_mask
) ? alt_modifier
: 0)
6223 | ((state
& dpyinfo
->super_mod_mask
) ? super_modifier
: 0)
6224 | ((state
& dpyinfo
->hyper_mod_mask
) ? hyper_modifier
: 0));
6228 x_emacs_to_x_modifiers (dpyinfo
, state
)
6229 struct x_display_info
*dpyinfo
;
6232 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
6233 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
6234 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
6235 | ((state
& shift_modifier
) ? ShiftMask
: 0)
6236 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
6237 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
6240 /* Convert a keysym to its name. */
6243 x_get_keysym_name (keysym
)
6249 value
= XKeysymToString (keysym
);
6257 /* Mouse clicks and mouse movement. Rah. */
6259 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6260 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6261 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6262 not force the value into range. */
6265 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
6267 register int pix_x
, pix_y
;
6268 register int *x
, *y
;
6272 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6273 even for negative values. */
6275 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
6277 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
6279 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
6280 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
6284 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
6285 bounds
->height
= f
->output_data
.x
->line_height
;
6286 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
6287 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
6294 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
6295 pix_x
= FRAME_WINDOW_WIDTH (f
);
6299 else if (pix_y
> f
->height
)
6308 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6309 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6310 can't tell the positions because W's display is not up to date,
6314 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
6317 int *frame_x
, *frame_y
;
6321 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
6322 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
6324 if (display_completed
)
6326 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6327 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
6328 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
6334 *frame_x
+= glyph
->pixel_width
;
6342 *frame_y
= *frame_x
= 0;
6346 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6347 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6352 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6354 If the event is a button press, then note that we have grabbed
6358 construct_mouse_click (result
, event
, f
)
6359 struct input_event
*result
;
6360 XButtonEvent
*event
;
6363 /* Make the event type no_event; we'll change that when we decide
6365 result
->kind
= mouse_click
;
6366 result
->code
= event
->button
- Button1
;
6367 result
->timestamp
= event
->time
;
6368 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6370 | (event
->type
== ButtonRelease
6374 XSETINT (result
->x
, event
->x
);
6375 XSETINT (result
->y
, event
->y
);
6376 XSETFRAME (result
->frame_or_window
, f
);
6382 /* Function to report a mouse movement to the mainstream Emacs code.
6383 The input handler calls this.
6385 We have received a mouse movement event, which is given in *event.
6386 If the mouse is over a different glyph than it was last time, tell
6387 the mainstream emacs code by setting mouse_moved. If not, ask for
6388 another motion event, so we can check again the next time it moves. */
6390 static XMotionEvent last_mouse_motion_event
;
6391 static Lisp_Object last_mouse_motion_frame
;
6394 note_mouse_movement (frame
, event
)
6396 XMotionEvent
*event
;
6398 last_mouse_movement_time
= event
->time
;
6399 last_mouse_motion_event
= *event
;
6400 XSETFRAME (last_mouse_motion_frame
, frame
);
6402 if (event
->window
!= FRAME_X_WINDOW (frame
))
6404 frame
->mouse_moved
= 1;
6405 last_mouse_scroll_bar
= Qnil
;
6406 note_mouse_highlight (frame
, -1, -1);
6409 /* Has the mouse moved off the glyph it was on at the last sighting? */
6410 else if (event
->x
< last_mouse_glyph
.x
6411 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
6412 || event
->y
< last_mouse_glyph
.y
6413 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
6415 frame
->mouse_moved
= 1;
6416 last_mouse_scroll_bar
= Qnil
;
6417 note_mouse_highlight (frame
, event
->x
, event
->y
);
6421 /* This is used for debugging, to turn off note_mouse_highlight. */
6423 int disable_mouse_highlight
;
6427 /************************************************************************
6429 ************************************************************************/
6431 /* Find the glyph under window-relative coordinates X/Y in window W.
6432 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6433 strings. Return in *HPOS and *VPOS the row and column number of
6434 the glyph found. Return in *AREA the glyph area containing X.
6435 Value is a pointer to the glyph found or null if X/Y is not on
6436 text, or we can't tell because W's current matrix is not up to
6439 static struct glyph
*
6440 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
)
6443 int *hpos
, *vpos
, *area
;
6445 struct glyph
*glyph
, *end
;
6446 struct glyph_row
*row
= NULL
;
6447 int x0
, i
, left_area_width
;
6449 /* Find row containing Y. Give up if some row is not enabled. */
6450 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6452 row
= MATRIX_ROW (w
->current_matrix
, i
);
6453 if (!row
->enabled_p
)
6455 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6462 /* Give up if Y is not in the window. */
6463 if (i
== w
->current_matrix
->nrows
)
6466 /* Get the glyph area containing X. */
6467 if (w
->pseudo_window_p
)
6474 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6475 if (x
< left_area_width
)
6477 *area
= LEFT_MARGIN_AREA
;
6480 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6483 x0
= row
->x
+ left_area_width
;
6487 *area
= RIGHT_MARGIN_AREA
;
6488 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6492 /* Find glyph containing X. */
6493 glyph
= row
->glyphs
[*area
];
6494 end
= glyph
+ row
->used
[*area
];
6497 if (x
< x0
+ glyph
->pixel_width
)
6499 if (w
->pseudo_window_p
)
6501 else if (BUFFERP (glyph
->object
))
6505 x0
+= glyph
->pixel_width
;
6512 *hpos
= glyph
- row
->glyphs
[*area
];
6517 /* Convert frame-relative x/y to coordinates relative to window W.
6518 Takes pseudo-windows into account. */
6521 frame_to_window_pixel_xy (w
, x
, y
)
6525 if (w
->pseudo_window_p
)
6527 /* A pseudo-window is always full-width, and starts at the
6528 left edge of the frame, plus a frame border. */
6529 struct frame
*f
= XFRAME (w
->frame
);
6530 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6531 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6535 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6536 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6541 /* Take proper action when mouse has moved to the mode or header line of
6542 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6543 mode line. X is relative to the start of the text display area of
6544 W, so the width of bitmap areas and scroll bars must be subtracted
6545 to get a position relative to the start of the mode line. */
6548 note_mode_line_highlight (w
, x
, mode_line_p
)
6552 struct frame
*f
= XFRAME (w
->frame
);
6553 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6554 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6555 struct glyph_row
*row
;
6558 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6560 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6564 struct glyph
*glyph
, *end
;
6565 Lisp_Object help
, map
;
6568 /* Find the glyph under X. */
6569 glyph
= row
->glyphs
[TEXT_AREA
];
6570 end
= glyph
+ row
->used
[TEXT_AREA
];
6571 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6572 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
));
6575 && x
>= x0
+ glyph
->pixel_width
)
6577 x0
+= glyph
->pixel_width
;
6582 && STRINGP (glyph
->object
)
6583 && XSTRING (glyph
->object
)->intervals
6584 && glyph
->charpos
>= 0
6585 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6587 /* If we're on a string with `help-echo' text property,
6588 arrange for the help to be displayed. This is done by
6589 setting the global variable help_echo to the help string. */
6590 help
= Fget_text_property (make_number (glyph
->charpos
),
6591 Qhelp_echo
, glyph
->object
);
6595 XSETWINDOW (help_echo_window
, w
);
6596 help_echo_object
= glyph
->object
;
6597 help_echo_pos
= glyph
->charpos
;
6600 /* Change the mouse pointer according to what is under X/Y. */
6601 map
= Fget_text_property (make_number (glyph
->charpos
),
6602 Qlocal_map
, glyph
->object
);
6604 cursor
= f
->output_data
.x
->nontext_cursor
;
6607 map
= Fget_text_property (make_number (glyph
->charpos
),
6608 Qkeymap
, glyph
->object
);
6610 cursor
= f
->output_data
.x
->nontext_cursor
;
6615 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6619 /* Take proper action when the mouse has moved to position X, Y on
6620 frame F as regards highlighting characters that have mouse-face
6621 properties. Also de-highlighting chars where the mouse was before.
6622 X and Y can be negative or out of range. */
6625 note_mouse_highlight (f
, x
, y
)
6629 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6634 /* When a menu is active, don't highlight because this looks odd. */
6635 #ifdef USE_X_TOOLKIT
6636 if (popup_activated ())
6640 if (disable_mouse_highlight
6641 || !f
->glyphs_initialized_p
)
6644 dpyinfo
->mouse_face_mouse_x
= x
;
6645 dpyinfo
->mouse_face_mouse_y
= y
;
6646 dpyinfo
->mouse_face_mouse_frame
= f
;
6648 if (dpyinfo
->mouse_face_defer
)
6653 dpyinfo
->mouse_face_deferred_gc
= 1;
6657 /* Which window is that in? */
6658 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6660 /* If we were displaying active text in another window, clear that. */
6661 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6662 clear_mouse_face (dpyinfo
);
6664 /* Not on a window -> return. */
6665 if (!WINDOWP (window
))
6668 /* Convert to window-relative pixel coordinates. */
6669 w
= XWINDOW (window
);
6670 frame_to_window_pixel_xy (w
, &x
, &y
);
6672 /* Handle tool-bar window differently since it doesn't display a
6674 if (EQ (window
, f
->tool_bar_window
))
6676 note_tool_bar_highlight (f
, x
, y
);
6680 if (portion
== 1 || portion
== 3)
6682 /* Mouse is on the mode or top line. */
6683 note_mode_line_highlight (w
, x
, portion
== 1);
6686 else if (portion
== 2)
6687 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6688 f
->output_data
.x
->horizontal_drag_cursor
);
6690 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6691 f
->output_data
.x
->text_cursor
);
6693 /* Are we in a window whose display is up to date?
6694 And verify the buffer's text has not changed. */
6695 if (/* Within text portion of the window. */
6697 && EQ (w
->window_end_valid
, w
->buffer
)
6698 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
6699 && (XFASTINT (w
->last_overlay_modified
)
6700 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
6702 int hpos
, vpos
, pos
, i
, area
;
6703 struct glyph
*glyph
;
6705 /* Find the glyph under X/Y. */
6706 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
);
6708 /* Clear mouse face if X/Y not over text. */
6710 || area
!= TEXT_AREA
6711 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6713 clear_mouse_face (dpyinfo
);
6717 pos
= glyph
->charpos
;
6718 xassert (w
->pseudo_window_p
|| BUFFERP (glyph
->object
));
6720 /* Check for mouse-face and help-echo. */
6722 Lisp_Object mouse_face
, overlay
, position
;
6723 Lisp_Object
*overlay_vec
;
6725 struct buffer
*obuf
;
6728 /* If we get an out-of-range value, return now; avoid an error. */
6729 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
6732 /* Make the window's buffer temporarily current for
6733 overlays_at and compute_char_face. */
6734 obuf
= current_buffer
;
6735 current_buffer
= XBUFFER (w
->buffer
);
6741 /* Is this char mouse-active or does it have help-echo? */
6742 XSETINT (position
, pos
);
6744 /* Put all the overlays we want in a vector in overlay_vec.
6745 Store the length in len. If there are more than 10, make
6746 enough space for all, and try again. */
6748 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6749 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
6750 if (noverlays
> len
)
6753 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6754 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
,0);
6757 /* Sort overlays into increasing priority order. */
6758 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6760 /* Check mouse-face highlighting. */
6761 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
6762 && vpos
>= dpyinfo
->mouse_face_beg_row
6763 && vpos
<= dpyinfo
->mouse_face_end_row
6764 && (vpos
> dpyinfo
->mouse_face_beg_row
6765 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6766 && (vpos
< dpyinfo
->mouse_face_end_row
6767 || hpos
< dpyinfo
->mouse_face_end_col
6768 || dpyinfo
->mouse_face_past_end
)))
6770 /* Clear the display of the old active region, if any. */
6771 clear_mouse_face (dpyinfo
);
6773 /* Find the highest priority overlay that has a mouse-face prop. */
6775 for (i
= noverlays
- 1; i
>= 0; --i
)
6777 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
6778 if (!NILP (mouse_face
))
6780 overlay
= overlay_vec
[i
];
6785 /* If no overlay applies, get a text property. */
6787 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
6789 /* Handle the overlay case. */
6790 if (! NILP (overlay
))
6792 /* Find the range of text around this char that
6793 should be active. */
6794 Lisp_Object before
, after
;
6797 before
= Foverlay_start (overlay
);
6798 after
= Foverlay_end (overlay
);
6799 /* Record this as the current active region. */
6800 fast_find_position (w
, XFASTINT (before
),
6801 &dpyinfo
->mouse_face_beg_col
,
6802 &dpyinfo
->mouse_face_beg_row
,
6803 &dpyinfo
->mouse_face_beg_x
,
6804 &dpyinfo
->mouse_face_beg_y
);
6805 dpyinfo
->mouse_face_past_end
6806 = !fast_find_position (w
, XFASTINT (after
),
6807 &dpyinfo
->mouse_face_end_col
,
6808 &dpyinfo
->mouse_face_end_row
,
6809 &dpyinfo
->mouse_face_end_x
,
6810 &dpyinfo
->mouse_face_end_y
);
6811 dpyinfo
->mouse_face_window
= window
;
6812 dpyinfo
->mouse_face_face_id
6813 = face_at_buffer_position (w
, pos
, 0, 0,
6814 &ignore
, pos
+ 1, 1);
6816 /* Display it as active. */
6817 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6819 /* Handle the text property case. */
6820 else if (! NILP (mouse_face
))
6822 /* Find the range of text around this char that
6823 should be active. */
6824 Lisp_Object before
, after
, beginning
, end
;
6827 beginning
= Fmarker_position (w
->start
);
6828 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
6829 - XFASTINT (w
->window_end_pos
)));
6831 = Fprevious_single_property_change (make_number (pos
+ 1),
6833 w
->buffer
, beginning
);
6835 = Fnext_single_property_change (position
, Qmouse_face
,
6837 /* Record this as the current active region. */
6838 fast_find_position (w
, XFASTINT (before
),
6839 &dpyinfo
->mouse_face_beg_col
,
6840 &dpyinfo
->mouse_face_beg_row
,
6841 &dpyinfo
->mouse_face_beg_x
,
6842 &dpyinfo
->mouse_face_beg_y
);
6843 dpyinfo
->mouse_face_past_end
6844 = !fast_find_position (w
, XFASTINT (after
),
6845 &dpyinfo
->mouse_face_end_col
,
6846 &dpyinfo
->mouse_face_end_row
,
6847 &dpyinfo
->mouse_face_end_x
,
6848 &dpyinfo
->mouse_face_end_y
);
6849 dpyinfo
->mouse_face_window
= window
;
6850 dpyinfo
->mouse_face_face_id
6851 = face_at_buffer_position (w
, pos
, 0, 0,
6852 &ignore
, pos
+ 1, 1);
6854 /* Display it as active. */
6855 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6859 /* Look for a `help-echo' property. */
6861 Lisp_Object help
, overlay
;
6863 /* Check overlays first. */
6864 help
= overlay
= Qnil
;
6865 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
6867 overlay
= overlay_vec
[i
];
6868 help
= Foverlay_get (overlay
, Qhelp_echo
);
6874 help_echo_window
= window
;
6875 help_echo_object
= overlay
;
6876 help_echo_pos
= pos
;
6880 /* Try text properties. */
6881 if ((STRINGP (glyph
->object
)
6882 && glyph
->charpos
>= 0
6883 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6884 || (BUFFERP (glyph
->object
)
6885 && glyph
->charpos
>= BEGV
6886 && glyph
->charpos
< ZV
))
6887 help
= Fget_text_property (make_number (glyph
->charpos
),
6888 Qhelp_echo
, glyph
->object
);
6893 help_echo_window
= window
;
6894 help_echo_object
= glyph
->object
;
6895 help_echo_pos
= glyph
->charpos
;
6902 current_buffer
= obuf
;
6908 redo_mouse_highlight ()
6910 if (!NILP (last_mouse_motion_frame
)
6911 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
6912 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
6913 last_mouse_motion_event
.x
,
6914 last_mouse_motion_event
.y
);
6919 /***********************************************************************
6921 ***********************************************************************/
6923 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
6924 struct glyph
**, int *, int *, int *));
6926 /* Tool-bar item index of the item on which a mouse button was pressed
6929 static int last_tool_bar_item
;
6932 /* Get information about the tool-bar item at position X/Y on frame F.
6933 Return in *GLYPH a pointer to the glyph of the tool-bar item in
6934 the current matrix of the tool-bar window of F, or NULL if not
6935 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
6936 item in F->tool_bar_items. Value is
6938 -1 if X/Y is not on a tool-bar item
6939 0 if X/Y is on the same item that was highlighted before.
6943 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
6946 struct glyph
**glyph
;
6947 int *hpos
, *vpos
, *prop_idx
;
6949 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6950 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6953 /* Find the glyph under X/Y. */
6954 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
);
6958 /* Get the start of this tool-bar item's properties in
6959 f->tool_bar_items. */
6960 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
6963 /* Is mouse on the highlighted item? */
6964 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
6965 && *vpos
>= dpyinfo
->mouse_face_beg_row
6966 && *vpos
<= dpyinfo
->mouse_face_end_row
6967 && (*vpos
> dpyinfo
->mouse_face_beg_row
6968 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
6969 && (*vpos
< dpyinfo
->mouse_face_end_row
6970 || *hpos
< dpyinfo
->mouse_face_end_col
6971 || dpyinfo
->mouse_face_past_end
))
6978 /* Handle mouse button event on the tool-bar of frame F, at
6979 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
6983 x_handle_tool_bar_click (f
, button_event
)
6985 XButtonEvent
*button_event
;
6987 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6988 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6989 int hpos
, vpos
, prop_idx
;
6990 struct glyph
*glyph
;
6991 Lisp_Object enabled_p
;
6992 int x
= button_event
->x
;
6993 int y
= button_event
->y
;
6995 /* If not on the highlighted tool-bar item, return. */
6996 frame_to_window_pixel_xy (w
, &x
, &y
);
6997 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
7000 /* If item is disabled, do nothing. */
7001 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7002 if (NILP (enabled_p
))
7005 if (button_event
->type
== ButtonPress
)
7007 /* Show item in pressed state. */
7008 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
7009 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
7010 last_tool_bar_item
= prop_idx
;
7014 Lisp_Object key
, frame
;
7015 struct input_event event
;
7017 /* Show item in released state. */
7018 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
7019 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
7021 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
7023 XSETFRAME (frame
, f
);
7024 event
.kind
= TOOL_BAR_EVENT
;
7025 event
.frame_or_window
= frame
;
7027 kbd_buffer_store_event (&event
);
7029 event
.kind
= TOOL_BAR_EVENT
;
7030 event
.frame_or_window
= frame
;
7032 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
7033 button_event
->state
);
7034 kbd_buffer_store_event (&event
);
7035 last_tool_bar_item
= -1;
7040 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7041 tool-bar window-relative coordinates X/Y. Called from
7042 note_mouse_highlight. */
7045 note_tool_bar_highlight (f
, x
, y
)
7049 Lisp_Object window
= f
->tool_bar_window
;
7050 struct window
*w
= XWINDOW (window
);
7051 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7053 struct glyph
*glyph
;
7054 struct glyph_row
*row
;
7056 Lisp_Object enabled_p
;
7058 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
7059 int mouse_down_p
, rc
;
7061 /* Function note_mouse_highlight is called with negative x(y
7062 values when mouse moves outside of the frame. */
7063 if (x
<= 0 || y
<= 0)
7065 clear_mouse_face (dpyinfo
);
7069 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
7072 /* Not on tool-bar item. */
7073 clear_mouse_face (dpyinfo
);
7077 /* On same tool-bar item as before. */
7080 clear_mouse_face (dpyinfo
);
7082 /* Mouse is down, but on different tool-bar item? */
7083 mouse_down_p
= (dpyinfo
->grabbed
7084 && f
== last_mouse_frame
7085 && FRAME_LIVE_P (f
));
7087 && last_tool_bar_item
!= prop_idx
)
7090 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
7091 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
7093 /* If tool-bar item is not enabled, don't highlight it. */
7094 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7095 if (!NILP (enabled_p
))
7097 /* Compute the x-position of the glyph. In front and past the
7098 image is a space. We include this is the highlighted area. */
7099 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
7100 for (i
= x
= 0; i
< hpos
; ++i
)
7101 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
7103 /* Record this as the current active region. */
7104 dpyinfo
->mouse_face_beg_col
= hpos
;
7105 dpyinfo
->mouse_face_beg_row
= vpos
;
7106 dpyinfo
->mouse_face_beg_x
= x
;
7107 dpyinfo
->mouse_face_beg_y
= row
->y
;
7108 dpyinfo
->mouse_face_past_end
= 0;
7110 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
7111 dpyinfo
->mouse_face_end_row
= vpos
;
7112 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
7113 dpyinfo
->mouse_face_end_y
= row
->y
;
7114 dpyinfo
->mouse_face_window
= window
;
7115 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
7117 /* Display it as active. */
7118 show_mouse_face (dpyinfo
, draw
);
7119 dpyinfo
->mouse_face_image_state
= draw
;
7124 /* Set help_echo to a help string.to display for this tool-bar item.
7125 XTread_socket does the rest. */
7126 help_echo_object
= help_echo_window
= Qnil
;
7128 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
7129 if (NILP (help_echo
))
7130 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
7135 /* Find the glyph matrix position of buffer position POS in window W.
7136 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7137 current glyphs must be up to date. If POS is above window start
7138 return (0, 0, 0, 0). If POS is after end of W, return end of
7142 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
)
7145 int *hpos
, *vpos
, *x
, *y
;
7149 int maybe_next_line_p
= 0;
7150 int line_start_position
;
7151 int yb
= window_text_bottom_y (w
);
7152 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
7153 struct glyph_row
*best_row
= row
;
7154 int row_vpos
= 0, best_row_vpos
= 0;
7159 if (row
->used
[TEXT_AREA
])
7160 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
7162 line_start_position
= 0;
7164 if (line_start_position
> pos
)
7166 /* If the position sought is the end of the buffer,
7167 don't include the blank lines at the bottom of the window. */
7168 else if (line_start_position
== pos
7169 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
7171 maybe_next_line_p
= 1;
7174 else if (line_start_position
> 0)
7177 best_row_vpos
= row_vpos
;
7180 if (row
->y
+ row
->height
>= yb
)
7187 /* Find the right column within BEST_ROW. */
7189 current_x
= best_row
->x
;
7190 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
7192 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
7195 charpos
= glyph
->charpos
;
7199 *vpos
= best_row_vpos
;
7204 else if (charpos
> pos
)
7206 else if (charpos
> 0)
7209 current_x
+= glyph
->pixel_width
;
7212 /* If we're looking for the end of the buffer,
7213 and we didn't find it in the line we scanned,
7214 use the start of the following line. */
7215 if (maybe_next_line_p
)
7220 current_x
= best_row
->x
;
7223 *vpos
= best_row_vpos
;
7224 *hpos
= lastcol
+ 1;
7231 /* Display the active region described by mouse_face_*
7232 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7235 show_mouse_face (dpyinfo
, draw
)
7236 struct x_display_info
*dpyinfo
;
7237 enum draw_glyphs_face draw
;
7239 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
7240 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7242 int cursor_off_p
= 0;
7243 struct cursor_pos saved_cursor
;
7245 saved_cursor
= output_cursor
;
7247 /* If window is in the process of being destroyed, don't bother
7249 if (w
->current_matrix
== NULL
)
7252 /* Recognize when we are called to operate on rows that don't exist
7253 anymore. This can happen when a window is split. */
7254 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
7257 set_output_cursor (&w
->phys_cursor
);
7259 /* Note that mouse_face_beg_row etc. are window relative. */
7260 for (i
= dpyinfo
->mouse_face_beg_row
;
7261 i
<= dpyinfo
->mouse_face_end_row
;
7264 int start_hpos
, end_hpos
, start_x
;
7265 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
7267 /* Don't do anything if row doesn't have valid contents. */
7268 if (!row
->enabled_p
)
7271 /* For all but the first row, the highlight starts at column 0. */
7272 if (i
== dpyinfo
->mouse_face_beg_row
)
7274 start_hpos
= dpyinfo
->mouse_face_beg_col
;
7275 start_x
= dpyinfo
->mouse_face_beg_x
;
7283 if (i
== dpyinfo
->mouse_face_end_row
)
7284 end_hpos
= dpyinfo
->mouse_face_end_col
;
7286 end_hpos
= row
->used
[TEXT_AREA
];
7288 /* If the cursor's in the text we are about to rewrite, turn the
7290 if (!w
->pseudo_window_p
7291 && i
== output_cursor
.vpos
7292 && output_cursor
.hpos
>= start_hpos
- 1
7293 && output_cursor
.hpos
<= end_hpos
)
7295 x_update_window_cursor (w
, 0);
7299 if (end_hpos
> start_hpos
)
7301 row
->mouse_face_p
= draw
== DRAW_MOUSE_FACE
;
7302 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
7303 start_hpos
, end_hpos
, draw
, NULL
, NULL
, 0);
7307 /* If we turned the cursor off, turn it back on. */
7309 x_display_cursor (w
, 1,
7310 output_cursor
.hpos
, output_cursor
.vpos
,
7311 output_cursor
.x
, output_cursor
.y
);
7313 output_cursor
= saved_cursor
;
7317 /* Change the mouse cursor. */
7318 if (draw
== DRAW_NORMAL_TEXT
)
7319 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7320 f
->output_data
.x
->text_cursor
);
7321 else if (draw
== DRAW_MOUSE_FACE
)
7322 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7323 f
->output_data
.x
->cross_cursor
);
7325 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7326 f
->output_data
.x
->nontext_cursor
);
7329 /* Clear out the mouse-highlighted active region.
7330 Redraw it un-highlighted first. */
7333 clear_mouse_face (dpyinfo
)
7334 struct x_display_info
*dpyinfo
;
7336 #if 0 /* This prevents redrawing tool bar items when changing from one
7337 to another while a tooltip is open, so don't do it. */
7338 if (!NILP (tip_frame
))
7342 if (! NILP (dpyinfo
->mouse_face_window
))
7343 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7345 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7346 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7347 dpyinfo
->mouse_face_window
= Qnil
;
7351 /* Clear any mouse-face on window W. This function is part of the
7352 redisplay interface, and is called from try_window_id and similar
7353 functions to ensure the mouse-highlight is off. */
7356 x_clear_mouse_face (w
)
7359 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
7363 XSETWINDOW (window
, w
);
7364 if (EQ (window
, dpyinfo
->mouse_face_window
))
7365 clear_mouse_face (dpyinfo
);
7370 /* Just discard the mouse face information for frame F, if any.
7371 This is used when the size of F is changed. */
7374 cancel_mouse_face (f
)
7378 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7380 window
= dpyinfo
->mouse_face_window
;
7381 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7383 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7384 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7385 dpyinfo
->mouse_face_window
= Qnil
;
7389 static struct scroll_bar
*x_window_to_scroll_bar ();
7390 static void x_scroll_bar_report_motion ();
7392 /* Return the current position of the mouse.
7393 *fp should be a frame which indicates which display to ask about.
7395 If the mouse movement started in a scroll bar, set *fp, *bar_window,
7396 and *part to the frame, window, and scroll bar part that the mouse
7397 is over. Set *x and *y to the portion and whole of the mouse's
7398 position on the scroll bar.
7400 If the mouse movement started elsewhere, set *fp to the frame the
7401 mouse is on, *bar_window to nil, and *x and *y to the character cell
7404 Set *time to the server time-stamp for the time at which the mouse
7405 was at this position.
7407 Don't store anything if we don't have a valid set of values to report.
7409 This clears the mouse_moved flag, so we can wait for the next mouse
7413 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7416 Lisp_Object
*bar_window
;
7417 enum scroll_bar_part
*part
;
7419 unsigned long *time
;
7425 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7426 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7432 Window dummy_window
;
7435 Lisp_Object frame
, tail
;
7437 /* Clear the mouse-moved flag for every frame on this display. */
7438 FOR_EACH_FRAME (tail
, frame
)
7439 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
7440 XFRAME (frame
)->mouse_moved
= 0;
7442 last_mouse_scroll_bar
= Qnil
;
7444 /* Figure out which root window we're on. */
7445 XQueryPointer (FRAME_X_DISPLAY (*fp
),
7446 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
7448 /* The root window which contains the pointer. */
7451 /* Trash which we can't trust if the pointer is on
7452 a different screen. */
7455 /* The position on that root window. */
7458 /* More trash we can't trust. */
7461 /* Modifier keys and pointer buttons, about which
7463 (unsigned int *) &dummy
);
7465 /* Now we have a position on the root; find the innermost window
7466 containing the pointer. */
7470 int parent_x
= 0, parent_y
= 0;
7475 /* XTranslateCoordinates can get errors if the window
7476 structure is changing at the same time this function
7477 is running. So at least we must not crash from them. */
7479 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
7481 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
7482 && FRAME_LIVE_P (last_mouse_frame
))
7484 /* If mouse was grabbed on a frame, give coords for that frame
7485 even if the mouse is now outside it. */
7486 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7488 /* From-window, to-window. */
7489 root
, FRAME_X_WINDOW (last_mouse_frame
),
7491 /* From-position, to-position. */
7492 root_x
, root_y
, &win_x
, &win_y
,
7496 f1
= last_mouse_frame
;
7502 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7504 /* From-window, to-window. */
7507 /* From-position, to-position. */
7508 root_x
, root_y
, &win_x
, &win_y
,
7513 if (child
== None
|| child
== win
)
7521 /* Now we know that:
7522 win is the innermost window containing the pointer
7523 (XTC says it has no child containing the pointer),
7524 win_x and win_y are the pointer's position in it
7525 (XTC did this the last time through), and
7526 parent_x and parent_y are the pointer's position in win's parent.
7527 (They are what win_x and win_y were when win was child.
7528 If win is the root window, it has no parent, and
7529 parent_{x,y} are invalid, but that's okay, because we'll
7530 never use them in that case.) */
7532 /* Is win one of our frames? */
7533 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
7535 #ifdef USE_X_TOOLKIT
7536 /* If we end up with the menu bar window, say it's not
7539 && f1
->output_data
.x
->menubar_widget
7540 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
7542 #endif /* USE_X_TOOLKIT */
7545 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
7548 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
7550 /* If not, is it one of our scroll bars? */
7553 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
7557 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7563 if (f1
== 0 && insist
> 0)
7564 f1
= SELECTED_FRAME ();
7568 /* Ok, we found a frame. Store all the values.
7569 last_mouse_glyph is a rectangle used to reduce the
7570 generation of mouse events. To not miss any motion
7571 events, we must divide the frame into rectangles of the
7572 size of the smallest character that could be displayed
7573 on it, i.e. into the same rectangles that matrices on
7574 the frame are divided into. */
7576 #if OLD_REDISPLAY_CODE
7577 int ignore1
, ignore2
;
7578 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
7580 FRAME_X_DISPLAY_INFO (f1
)->grabbed
7584 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
7585 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
7589 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7590 round down even for negative values. */
7596 last_mouse_glyph
.width
= width
;
7597 last_mouse_glyph
.height
= height
;
7598 last_mouse_glyph
.x
= (x
+ width
- 1) / width
* width
;
7599 last_mouse_glyph
.y
= (y
+ height
- 1) / height
* height
;
7606 XSETINT (*x
, win_x
);
7607 XSETINT (*y
, win_y
);
7608 *time
= last_mouse_movement_time
;
7617 #ifdef USE_X_TOOLKIT
7619 /* Atimer callback function for TIMER. Called every 0.1s to process
7620 Xt timeouts, if needed. We must avoid calling XtAppPending as
7621 much as possible because that function does an implicit XFlush
7622 that slows us down. */
7625 x_process_timeouts (timer
)
7626 struct atimer
*timer
;
7628 if (toolkit_scroll_bar_interaction
|| popup_activated_flag
)
7631 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
7632 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
7637 #endif /* USE_X_TOOLKIT */
7640 /* Scroll bar support. */
7642 /* Given an X window ID, find the struct scroll_bar which manages it.
7643 This can be called in GC, so we have to make sure to strip off mark
7646 static struct scroll_bar
*
7647 x_window_to_scroll_bar (window_id
)
7652 for (tail
= Vframe_list
;
7653 XGCTYPE (tail
) == Lisp_Cons
;
7656 Lisp_Object frame
, bar
, condemned
;
7658 frame
= XCAR (tail
);
7659 /* All elements of Vframe_list should be frames. */
7660 if (! GC_FRAMEP (frame
))
7663 /* Scan this frame's scroll bar list for a scroll bar with the
7665 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
7666 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
7667 /* This trick allows us to search both the ordinary and
7668 condemned scroll bar lists with one loop. */
7669 ! GC_NILP (bar
) || (bar
= condemned
,
7672 bar
= XSCROLL_BAR (bar
)->next
)
7673 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
7674 return XSCROLL_BAR (bar
);
7682 /************************************************************************
7684 ************************************************************************/
7686 #ifdef USE_TOOLKIT_SCROLL_BARS
7688 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
7689 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
7690 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
7691 struct scroll_bar
*));
7692 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
7696 /* Id of action hook installed for scroll bars. */
7698 static XtActionHookId action_hook_id
;
7700 /* Lisp window being scrolled. Set when starting to interact with
7701 a toolkit scroll bar, reset to nil when ending the interaction. */
7703 static Lisp_Object window_being_scrolled
;
7705 /* Last scroll bar part sent in xm_scroll_callback. */
7707 static int last_scroll_bar_part
;
7709 /* Whether this is an Xaw with arrow-scrollbars. This should imply
7710 that movements of 1/20 of the screen size are mapped to up/down. */
7712 static Boolean xaw3d_arrow_scroll
;
7714 /* Whether the drag scrolling maintains the mouse at the top of the
7715 thumb. If not, resizing the thumb needs to be done more carefully
7716 to avoid jerkyness. */
7718 static Boolean xaw3d_pick_top
;
7721 /* Action hook installed via XtAppAddActionHook when toolkit scroll
7722 bars are used.. The hook is responsible for detecting when
7723 the user ends an interaction with the scroll bar, and generates
7724 a `end-scroll' scroll_bar_click' event if so. */
7727 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
7730 XtPointer client_data
;
7734 Cardinal
*num_params
;
7740 scroll_bar_p
= XmIsScrollBar (widget
);
7741 end_action
= "Release";
7742 #else /* !USE_MOTIF i.e. use Xaw */
7743 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
7744 end_action
= "EndScroll";
7745 #endif /* USE_MOTIF */
7748 && strcmp (action_name
, end_action
) == 0
7749 && WINDOWP (window_being_scrolled
))
7753 x_send_scroll_bar_event (window_being_scrolled
,
7754 scroll_bar_end_scroll
, 0, 0);
7755 w
= XWINDOW (window_being_scrolled
);
7756 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
7757 window_being_scrolled
= Qnil
;
7758 last_scroll_bar_part
= -1;
7760 /* Xt timeouts no longer needed. */
7761 toolkit_scroll_bar_interaction
= 0;
7765 /* A vector of windows used for communication between
7766 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
7768 static struct window
**scroll_bar_windows
;
7769 static int scroll_bar_windows_size
;
7772 /* Send a client message with message type Xatom_Scrollbar for a
7773 scroll action to the frame of WINDOW. PART is a value identifying
7774 the part of the scroll bar that was clicked on. PORTION is the
7775 amount to scroll of a whole of WHOLE. */
7778 x_send_scroll_bar_event (window
, part
, portion
, whole
)
7780 int part
, portion
, whole
;
7783 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
7784 struct window
*w
= XWINDOW (window
);
7785 struct frame
*f
= XFRAME (w
->frame
);
7790 /* Construct a ClientMessage event to send to the frame. */
7791 ev
->type
= ClientMessage
;
7792 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
7793 ev
->display
= FRAME_X_DISPLAY (f
);
7794 ev
->window
= FRAME_X_WINDOW (f
);
7797 /* We can only transfer 32 bits in the XClientMessageEvent, which is
7798 not enough to store a pointer or Lisp_Object on a 64 bit system.
7799 So, store the window in scroll_bar_windows and pass the index
7800 into that array in the event. */
7801 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
7802 if (scroll_bar_windows
[i
] == NULL
)
7805 if (i
== scroll_bar_windows_size
)
7807 int new_size
= max (10, 2 * scroll_bar_windows_size
);
7808 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
7809 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
7811 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
7813 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
7814 scroll_bar_windows_size
= new_size
;
7817 scroll_bar_windows
[i
] = w
;
7818 ev
->data
.l
[0] = (long) i
;
7819 ev
->data
.l
[1] = (long) part
;
7820 ev
->data
.l
[2] = (long) 0;
7821 ev
->data
.l
[3] = (long) portion
;
7822 ev
->data
.l
[4] = (long) whole
;
7824 /* Make Xt timeouts work while the scroll bar is active. */
7825 toolkit_scroll_bar_interaction
= 1;
7827 /* Setting the event mask to zero means that the message will
7828 be sent to the client that created the window, and if that
7829 window no longer exists, no event will be sent. */
7830 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
7835 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
7839 x_scroll_bar_to_input_event (event
, ievent
)
7841 struct input_event
*ievent
;
7843 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
7848 w
= scroll_bar_windows
[ev
->data
.l
[0]];
7849 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
7851 XSETWINDOW (window
, w
);
7852 f
= XFRAME (w
->frame
);
7854 ievent
->kind
= scroll_bar_click
;
7855 ievent
->frame_or_window
= window
;
7857 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
7858 ievent
->part
= ev
->data
.l
[1];
7859 ievent
->code
= ev
->data
.l
[2];
7860 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
7861 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
7862 ievent
->modifiers
= 0;
7868 /* Minimum and maximum values used for Motif scroll bars. */
7871 #define XM_SB_MAX 10000000
7872 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
7875 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
7876 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
7877 CALL_DATA is a pointer a a XmScrollBarCallbackStruct. */
7880 xm_scroll_callback (widget
, client_data
, call_data
)
7882 XtPointer client_data
, call_data
;
7884 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7885 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
7887 int part
= -1, whole
= 0, portion
= 0;
7891 case XmCR_DECREMENT
:
7892 bar
->dragging
= Qnil
;
7893 part
= scroll_bar_up_arrow
;
7896 case XmCR_INCREMENT
:
7897 bar
->dragging
= Qnil
;
7898 part
= scroll_bar_down_arrow
;
7901 case XmCR_PAGE_DECREMENT
:
7902 bar
->dragging
= Qnil
;
7903 part
= scroll_bar_above_handle
;
7906 case XmCR_PAGE_INCREMENT
:
7907 bar
->dragging
= Qnil
;
7908 part
= scroll_bar_below_handle
;
7912 bar
->dragging
= Qnil
;
7913 part
= scroll_bar_to_top
;
7916 case XmCR_TO_BOTTOM
:
7917 bar
->dragging
= Qnil
;
7918 part
= scroll_bar_to_bottom
;
7924 int dragging_down_p
= (INTEGERP (bar
->dragging
)
7925 && XINT (bar
->dragging
) <= cs
->value
);
7927 /* Get the slider size. */
7929 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
7932 /* At the max position of the scroll bar, do a line-wise
7933 movement. Without doing anything, the LessTif scroll bar
7934 calls us with the same cs->value again and again. If we
7935 want to make sure that we can reach the end of the buffer,
7936 we have to do something.
7938 Implementation note: setting bar->dragging always to
7939 cs->value gives a smoother movement at the max position.
7940 Setting it to nil when doing line-wise movement gives
7941 a better slider behavior. */
7943 if (cs
->value
+ slider_size
== XM_SB_MAX
7945 && last_scroll_bar_part
== scroll_bar_down_arrow
))
7947 part
= scroll_bar_down_arrow
;
7948 bar
->dragging
= Qnil
;
7952 whole
= XM_SB_RANGE
;
7953 portion
= min (cs
->value
- XM_SB_MIN
, XM_SB_MAX
- slider_size
);
7954 part
= scroll_bar_handle
;
7955 bar
->dragging
= make_number (cs
->value
);
7960 case XmCR_VALUE_CHANGED
:
7966 window_being_scrolled
= bar
->window
;
7967 last_scroll_bar_part
= part
;
7968 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
7973 #else /* !USE_MOTIF, i.e. Xaw. */
7976 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
7977 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
7978 scroll bar struct. CALL_DATA is a pointer to a float saying where
7982 xaw_jump_callback (widget
, client_data
, call_data
)
7984 XtPointer client_data
, call_data
;
7986 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7987 float top
= *(float *) call_data
;
7989 int whole
, portion
, height
;
7992 /* Get the size of the thumb, a value between 0 and 1. */
7994 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
7998 portion
= shown
< 1 ? top
* whole
: 0;
8000 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
8001 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
8002 the bottom, so we force the scrolling whenever we see that we're
8003 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
8004 we try to ensure that we always stay two pixels away from the
8006 part
= scroll_bar_down_arrow
;
8008 part
= scroll_bar_handle
;
8010 window_being_scrolled
= bar
->window
;
8011 bar
->dragging
= make_number (portion
);
8012 last_scroll_bar_part
= part
;
8013 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
8017 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
8018 i.e. line or page up or down. WIDGET is the Xaw scroll bar
8019 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
8020 the scroll bar. CALL_DATA is an integer specifying the action that
8021 has taken place. It's magnitude is in the range 0..height of the
8022 scroll bar. Negative values mean scroll towards buffer start.
8023 Values < height of scroll bar mean line-wise movement. */
8026 xaw_scroll_callback (widget
, client_data
, call_data
)
8028 XtPointer client_data
, call_data
;
8030 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
8031 int position
= (int) call_data
;
8035 /* Get the height of the scroll bar. */
8037 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
8040 if (abs (position
) >= height
)
8041 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
8043 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
8044 it maps line-movement to call_data = max(5, height/20). */
8045 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
8046 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
8048 part
= scroll_bar_move_ratio
;
8050 window_being_scrolled
= bar
->window
;
8051 bar
->dragging
= Qnil
;
8052 last_scroll_bar_part
= part
;
8053 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
8057 #endif /* not USE_MOTIF */
8060 /* Create the widget for scroll bar BAR on frame F. Record the widget
8061 and X window of the scroll bar in BAR. */
8064 x_create_toolkit_scroll_bar (f
, bar
)
8066 struct scroll_bar
*bar
;
8072 char *scroll_bar_name
= "verticalScrollBar";
8073 unsigned long pixel
;
8078 /* LessTif 0.85, problems:
8080 1. When the mouse if over the scroll bar, the scroll bar will
8081 get keyboard events. I didn't find a way to turn this off.
8083 2. Do we have to explicitly set the cursor to get an arrow
8084 cursor (see below)? */
8086 /* Set resources. Create the widget. */
8087 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8088 XtSetArg (av
[ac
], XmNminimum
, XM_SB_MIN
); ++ac
;
8089 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
8090 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
8091 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
8092 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
8093 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
8095 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8098 XtSetArg (av
[ac
], XmNforeground
, pixel
);
8102 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8105 XtSetArg (av
[ac
], XmNbackground
, pixel
);
8109 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
8110 scroll_bar_name
, av
, ac
);
8112 /* Add one callback for everything that can happen. */
8113 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
8115 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
8117 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
8119 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
8121 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
8123 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
8125 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
8128 /* Realize the widget. Only after that is the X window created. */
8129 XtRealizeWidget (widget
);
8131 /* Set the cursor to an arrow. I didn't find a resource to do that.
8132 And I'm wondering why it hasn't an arrow cursor by default. */
8133 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
8134 f
->output_data
.x
->nontext_cursor
);
8136 #else /* !USE_MOTIF i.e. use Xaw */
8138 /* Set resources. Create the widget. The background of the
8139 Xaw3d scroll bar widget is a little bit light for my taste.
8140 We don't alter it here to let users change it according
8141 to their taste with `emacs*verticalScrollBar.background: xxx'. */
8142 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
8143 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
8144 /* For smoother scrolling with Xaw3d -sm */
8145 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
8146 /* XtSetArg (av[ac], XtNbeNiceToColormap, True); ++ac; */
8148 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
8151 XtSetArg (av
[ac
], XtNforeground
, pixel
);
8155 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8158 XtSetArg (av
[ac
], XtNbackground
, pixel
);
8162 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
8163 f
->output_data
.x
->edit_widget
, av
, ac
);
8167 char *val
= initial
;
8168 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
8169 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
8171 { /* ARROW_SCROLL */
8172 xaw3d_arrow_scroll
= True
;
8173 /* Isn't that just a personal preference ? -sm */
8174 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
8178 /* Define callbacks. */
8179 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
8180 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
8183 /* Realize the widget. Only after that is the X window created. */
8184 XtRealizeWidget (widget
);
8186 #endif /* !USE_MOTIF */
8188 /* Install an action hook that let's us detect when the user
8189 finishes interacting with a scroll bar. */
8190 if (action_hook_id
== 0)
8191 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
8193 /* Remember X window and widget in the scroll bar vector. */
8194 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
8195 xwindow
= XtWindow (widget
);
8196 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
8202 /* Set the thumb size and position of scroll bar BAR. We are currently
8203 displaying PORTION out of a whole WHOLE, and our position POSITION. */
8206 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
8207 struct scroll_bar
*bar
;
8208 int portion
, position
, whole
;
8210 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8211 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
8218 top
= (float) position
/ whole
;
8219 shown
= (float) portion
/ whole
;
8227 Boolean arrow1_selected
, arrow2_selected
;
8228 unsigned char flags
;
8229 XmScrollBarWidget sb
;
8231 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
8232 is the scroll bar's maximum and MIN is the scroll bar's minimum
8234 size
= shown
* XM_SB_RANGE
;
8235 size
= min (size
, XM_SB_RANGE
);
8236 size
= max (size
, 1);
8238 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
8239 value
= top
* XM_SB_RANGE
;
8240 value
= min (value
, XM_SB_MAX
- size
);
8241 value
= max (value
, XM_SB_MIN
);
8243 /* LessTif: Calling XmScrollBarSetValues after an increment or
8244 decrement turns off auto-repeat LessTif-internally. This can
8245 be seen in ScrollBar.c which resets Arrow1Selected and
8246 Arrow2Selected. It also sets internal flags so that LessTif
8247 believes the mouse is in the slider. We either have to change
8248 our code, or work around that by accessing private data. */
8250 sb
= (XmScrollBarWidget
) widget
;
8251 arrow1_selected
= sb
->scrollBar
.arrow1_selected
;
8252 arrow2_selected
= sb
->scrollBar
.arrow2_selected
;
8253 flags
= sb
->scrollBar
.flags
;
8255 if (NILP (bar
->dragging
))
8256 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
8257 else if (last_scroll_bar_part
== scroll_bar_down_arrow
)
8258 /* This has the negative side effect that the slider value is
8259 not what it would be if we scrolled here using line-wise or
8260 page-wise movement. */
8261 XmScrollBarSetValues (widget
, value
, XM_SB_RANGE
- value
, 0, 0, False
);
8264 /* If currently dragging, only update the slider size.
8265 This reduces flicker effects. */
8266 int old_value
, old_size
, increment
, page_increment
;
8268 XmScrollBarGetValues (widget
, &old_value
, &old_size
,
8269 &increment
, &page_increment
);
8270 XmScrollBarSetValues (widget
, old_value
,
8271 min (size
, XM_SB_RANGE
- old_value
),
8275 sb
->scrollBar
.arrow1_selected
= arrow1_selected
;
8276 sb
->scrollBar
.arrow2_selected
= arrow2_selected
;
8277 sb
->scrollBar
.flags
= flags
;
8279 #else /* !USE_MOTIF i.e. use Xaw */
8281 float old_top
, old_shown
;
8283 XtVaGetValues (widget
,
8284 XtNtopOfThumb
, &old_top
,
8285 XtNshown
, &old_shown
,
8289 /* Massage the top+shown values. */
8290 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
8291 top
= max (0, min (1, top
));
8294 /* Keep two pixels available for moving the thumb down. */
8295 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
8297 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
8298 check that your system's configuration file contains a define
8299 for `NARROWPROTO'. See s/freebsd.h for an example. */
8300 if (top
!= old_top
|| shown
!= old_shown
)
8302 if (NILP (bar
->dragging
))
8303 XawScrollbarSetThumb (widget
, top
, shown
);
8307 ScrollbarWidget sb
= (ScrollbarWidget
) widget
;
8308 int scroll_mode
= 0;
8310 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
8311 if (xaw3d_arrow_scroll
)
8313 /* Xaw3d stupidly ignores resize requests while dragging
8314 so we have to make it believe it's not in dragging mode. */
8315 scroll_mode
= sb
->scrollbar
.scroll_mode
;
8316 if (scroll_mode
== 2)
8317 sb
->scrollbar
.scroll_mode
= 0;
8320 /* Try to make the scrolling a tad smoother. */
8321 if (!xaw3d_pick_top
)
8322 shown
= min (shown
, old_shown
);
8324 XawScrollbarSetThumb (widget
, top
, shown
);
8327 if (xaw3d_arrow_scroll
&& scroll_mode
== 2)
8328 sb
->scrollbar
.scroll_mode
= scroll_mode
;
8333 #endif /* !USE_MOTIF */
8338 #endif /* USE_TOOLKIT_SCROLL_BARS */
8342 /************************************************************************
8343 Scroll bars, general
8344 ************************************************************************/
8346 /* Create a scroll bar and return the scroll bar vector for it. W is
8347 the Emacs window on which to create the scroll bar. TOP, LEFT,
8348 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
8351 static struct scroll_bar
*
8352 x_scroll_bar_create (w
, top
, left
, width
, height
)
8354 int top
, left
, width
, height
;
8356 struct frame
*f
= XFRAME (w
->frame
);
8357 struct scroll_bar
*bar
8358 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
8362 #ifdef USE_TOOLKIT_SCROLL_BARS
8363 x_create_toolkit_scroll_bar (f
, bar
);
8364 #else /* not USE_TOOLKIT_SCROLL_BARS */
8366 XSetWindowAttributes a
;
8370 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
8371 if (a
.background_pixel
== -1)
8372 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
8374 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
8375 | ButtonMotionMask
| PointerMotionHintMask
8377 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
8379 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
8381 /* Clear the area of W that will serve as a scroll bar. This is
8382 for the case that a window has been split horizontally. In
8383 this case, no clear_frame is generated to reduce flickering. */
8384 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8386 window_box_height (w
), False
);
8388 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8389 /* Position and size of scroll bar. */
8390 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8392 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8394 /* Border width, depth, class, and visual. */
8401 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
8403 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8405 XSETWINDOW (bar
->window
, w
);
8406 XSETINT (bar
->top
, top
);
8407 XSETINT (bar
->left
, left
);
8408 XSETINT (bar
->width
, width
);
8409 XSETINT (bar
->height
, height
);
8410 XSETINT (bar
->start
, 0);
8411 XSETINT (bar
->end
, 0);
8412 bar
->dragging
= Qnil
;
8414 /* Add bar to its frame's list of scroll bars. */
8415 bar
->next
= FRAME_SCROLL_BARS (f
);
8417 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8418 if (!NILP (bar
->next
))
8419 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8421 /* Map the window/widget. */
8422 #ifdef USE_TOOLKIT_SCROLL_BARS
8424 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
8425 XtConfigureWidget (scroll_bar
,
8426 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8428 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8430 XtMapWidget (scroll_bar
);
8432 #else /* not USE_TOOLKIT_SCROLL_BARS */
8433 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
8434 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8441 /* Draw BAR's handle in the proper position.
8443 If the handle is already drawn from START to END, don't bother
8444 redrawing it, unless REBUILD is non-zero; in that case, always
8445 redraw it. (REBUILD is handy for drawing the handle after expose
8448 Normally, we want to constrain the start and end of the handle to
8449 fit inside its rectangle, but if the user is dragging the scroll
8450 bar handle, we want to let them drag it down all the way, so that
8451 the bar's top is as far down as it goes; otherwise, there's no way
8452 to move to the very end of the buffer. */
8454 #ifndef USE_TOOLKIT_SCROLL_BARS
8457 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
8458 struct scroll_bar
*bar
;
8462 int dragging
= ! NILP (bar
->dragging
);
8463 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8464 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8465 GC gc
= f
->output_data
.x
->normal_gc
;
8467 /* If the display is already accurate, do nothing. */
8469 && start
== XINT (bar
->start
)
8470 && end
== XINT (bar
->end
))
8476 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
8477 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8478 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8480 /* Make sure the values are reasonable, and try to preserve
8481 the distance between start and end. */
8483 int length
= end
- start
;
8487 else if (start
> top_range
)
8489 end
= start
+ length
;
8493 else if (end
> top_range
&& ! dragging
)
8497 /* Store the adjusted setting in the scroll bar. */
8498 XSETINT (bar
->start
, start
);
8499 XSETINT (bar
->end
, end
);
8501 /* Clip the end position, just for display. */
8502 if (end
> top_range
)
8505 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
8506 below top positions, to make sure the handle is always at least
8507 that many pixels tall. */
8508 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8510 /* Draw the empty space above the handle. Note that we can't clear
8511 zero-height areas; that means "clear to end of window." */
8513 x_clear_area (FRAME_X_DISPLAY (f
), w
,
8514 /* x, y, width, height, and exposures. */
8515 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8516 VERTICAL_SCROLL_BAR_TOP_BORDER
,
8517 inside_width
, start
,
8520 /* Change to proper foreground color if one is specified. */
8521 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8522 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8523 f
->output_data
.x
->scroll_bar_foreground_pixel
);
8525 /* Draw the handle itself. */
8526 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8528 /* x, y, width, height */
8529 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8530 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
8531 inside_width
, end
- start
);
8533 /* Restore the foreground color of the GC if we changed it above. */
8534 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8535 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8536 f
->output_data
.x
->foreground_pixel
);
8538 /* Draw the empty space below the handle. Note that we can't
8539 clear zero-height areas; that means "clear to end of window." */
8540 if (end
< inside_height
)
8541 x_clear_area (FRAME_X_DISPLAY (f
), w
,
8542 /* x, y, width, height, and exposures. */
8543 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8544 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
8545 inside_width
, inside_height
- end
,
8553 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8555 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
8559 x_scroll_bar_remove (bar
)
8560 struct scroll_bar
*bar
;
8562 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8565 #ifdef USE_TOOLKIT_SCROLL_BARS
8566 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
8568 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
8571 /* Disassociate this scroll bar from its window. */
8572 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
8578 /* Set the handle of the vertical scroll bar for WINDOW to indicate
8579 that we are displaying PORTION characters out of a total of WHOLE
8580 characters, starting at POSITION. If WINDOW has no scroll bar,
8584 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
8586 int portion
, whole
, position
;
8588 struct frame
*f
= XFRAME (w
->frame
);
8589 struct scroll_bar
*bar
;
8590 int top
, height
, left
, sb_left
, width
, sb_width
;
8591 int window_x
, window_y
, window_width
, window_height
;
8593 /* Get window dimensions. */
8594 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
8596 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
8597 height
= window_height
;
8599 /* Compute the left edge of the scroll bar area. */
8600 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8601 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
8603 left
= XFASTINT (w
->left
);
8604 left
*= CANON_X_UNIT (f
);
8605 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
8607 /* Compute the width of the scroll bar which might be less than
8608 the width of the area reserved for the scroll bar. */
8609 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
8610 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
8614 /* Compute the left edge of the scroll bar. */
8615 #ifdef USE_TOOLKIT_SCROLL_BARS
8616 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8617 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
8619 sb_left
= left
+ (width
- sb_width
) / 2;
8621 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8622 sb_left
= left
+ width
- sb_width
;
8627 /* Does the scroll bar exist yet? */
8628 if (NILP (w
->vertical_scroll_bar
))
8631 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8632 left
, top
, width
, height
, False
);
8634 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
8638 /* It may just need to be moved and resized. */
8639 unsigned int mask
= 0;
8641 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
8645 if (sb_left
!= XINT (bar
->left
))
8647 if (top
!= XINT (bar
->top
))
8649 if (sb_width
!= XINT (bar
->width
))
8651 if (height
!= XINT (bar
->height
))
8654 #ifdef USE_TOOLKIT_SCROLL_BARS
8656 /* Since toolkit scroll bars are smaller than the space reserved
8657 for them on the frame, we have to clear "under" them. */
8658 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8659 left
, top
, width
, height
, False
);
8661 /* Move/size the scroll bar widget. */
8663 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
8664 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8666 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8669 #else /* not USE_TOOLKIT_SCROLL_BARS */
8671 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
8673 /* Clear areas not covered by the scroll bar. This makes sure a
8674 previous mode line display is cleared after C-x 2 C-x 1, for
8675 example. Non-toolkit scroll bars are as wide as the area
8676 reserved for scroll bars - trim at both sides. */
8677 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8678 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8680 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8681 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8682 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8686 /* Move/size the scroll bar window. */
8691 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
8693 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
8695 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
8699 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8701 /* Remember new settings. */
8702 XSETINT (bar
->left
, sb_left
);
8703 XSETINT (bar
->top
, top
);
8704 XSETINT (bar
->width
, sb_width
);
8705 XSETINT (bar
->height
, height
);
8710 #ifdef USE_TOOLKIT_SCROLL_BARS
8711 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
8712 #else /* not USE_TOOLKIT_SCROLL_BARS */
8713 /* Set the scroll bar's current state, unless we're currently being
8715 if (NILP (bar
->dragging
))
8717 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
8720 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
8723 int start
= ((double) position
* top_range
) / whole
;
8724 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
8725 x_scroll_bar_set_handle (bar
, start
, end
, 0);
8728 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8730 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
8734 /* The following three hooks are used when we're doing a thorough
8735 redisplay of the frame. We don't explicitly know which scroll bars
8736 are going to be deleted, because keeping track of when windows go
8737 away is a real pain - "Can you say set-window-configuration, boys
8738 and girls?" Instead, we just assert at the beginning of redisplay
8739 that *all* scroll bars are to be removed, and then save a scroll bar
8740 from the fiery pit when we actually redisplay its window. */
8742 /* Arrange for all scroll bars on FRAME to be removed at the next call
8743 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
8744 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
8747 XTcondemn_scroll_bars (frame
)
8750 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
8751 while (! NILP (FRAME_SCROLL_BARS (frame
)))
8754 bar
= FRAME_SCROLL_BARS (frame
);
8755 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
8756 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
8757 XSCROLL_BAR (bar
)->prev
= Qnil
;
8758 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
8759 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
8760 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
8765 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
8766 Note that WINDOW isn't necessarily condemned at all. */
8769 XTredeem_scroll_bar (window
)
8770 struct window
*window
;
8772 struct scroll_bar
*bar
;
8775 /* We can't redeem this window's scroll bar if it doesn't have one. */
8776 if (NILP (window
->vertical_scroll_bar
))
8779 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
8781 /* Unlink it from the condemned list. */
8782 f
= XFRAME (WINDOW_FRAME (window
));
8783 if (NILP (bar
->prev
))
8785 /* If the prev pointer is nil, it must be the first in one of
8787 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
8788 /* It's not condemned. Everything's fine. */
8790 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
8791 window
->vertical_scroll_bar
))
8792 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
8794 /* If its prev pointer is nil, it must be at the front of
8795 one or the other! */
8799 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
8801 if (! NILP (bar
->next
))
8802 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
8804 bar
->next
= FRAME_SCROLL_BARS (f
);
8806 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8807 if (! NILP (bar
->next
))
8808 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8811 /* Remove all scroll bars on FRAME that haven't been saved since the
8812 last call to `*condemn_scroll_bars_hook'. */
8815 XTjudge_scroll_bars (f
)
8818 Lisp_Object bar
, next
;
8820 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
8822 /* Clear out the condemned list now so we won't try to process any
8823 more events on the hapless scroll bars. */
8824 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
8826 for (; ! NILP (bar
); bar
= next
)
8828 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
8830 x_scroll_bar_remove (b
);
8833 b
->next
= b
->prev
= Qnil
;
8836 /* Now there should be no references to the condemned scroll bars,
8837 and they should get garbage-collected. */
8841 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
8842 is a no-op when using toolkit scroll bars.
8844 This may be called from a signal handler, so we have to ignore GC
8848 x_scroll_bar_expose (bar
, event
)
8849 struct scroll_bar
*bar
;
8852 #ifndef USE_TOOLKIT_SCROLL_BARS
8854 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8855 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8856 GC gc
= f
->output_data
.x
->normal_gc
;
8857 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
8861 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
8863 /* Draw a one-pixel border just inside the edges of the scroll bar. */
8864 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8866 /* x, y, width, height */
8868 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
8869 XINT (bar
->height
) - 1);
8873 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8876 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
8877 is set to something other than no_event, it is enqueued.
8879 This may be called from a signal handler, so we have to ignore GC
8882 #ifndef USE_TOOLKIT_SCROLL_BARS
8885 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
8886 struct scroll_bar
*bar
;
8888 struct input_event
*emacs_event
;
8890 if (! GC_WINDOWP (bar
->window
))
8893 emacs_event
->kind
= scroll_bar_click
;
8894 emacs_event
->code
= event
->xbutton
.button
- Button1
;
8895 emacs_event
->modifiers
8896 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
8897 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
8898 event
->xbutton
.state
)
8899 | (event
->type
== ButtonRelease
8902 emacs_event
->frame_or_window
= bar
->window
;
8903 emacs_event
->arg
= Qnil
;
8904 emacs_event
->timestamp
= event
->xbutton
.time
;
8907 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8909 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8912 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8913 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
8916 if (y
> top_range
) y
= top_range
;
8918 if (y
< XINT (bar
->start
))
8919 emacs_event
->part
= scroll_bar_above_handle
;
8920 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
8921 emacs_event
->part
= scroll_bar_handle
;
8923 emacs_event
->part
= scroll_bar_below_handle
;
8925 /* Just because the user has clicked on the handle doesn't mean
8926 they want to drag it. Lisp code needs to be able to decide
8927 whether or not we're dragging. */
8929 /* If the user has just clicked on the handle, record where they're
8931 if (event
->type
== ButtonPress
8932 && emacs_event
->part
== scroll_bar_handle
)
8933 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
8936 /* If the user has released the handle, set it to its final position. */
8937 if (event
->type
== ButtonRelease
8938 && ! NILP (bar
->dragging
))
8940 int new_start
= y
- XINT (bar
->dragging
);
8941 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8943 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8944 bar
->dragging
= Qnil
;
8947 /* Same deal here as the other #if 0. */
8949 /* Clicks on the handle are always reported as occurring at the top of
8951 if (emacs_event
->part
== scroll_bar_handle
)
8952 emacs_event
->x
= bar
->start
;
8954 XSETINT (emacs_event
->x
, y
);
8956 XSETINT (emacs_event
->x
, y
);
8959 XSETINT (emacs_event
->y
, top_range
);
8963 /* Handle some mouse motion while someone is dragging the scroll bar.
8965 This may be called from a signal handler, so we have to ignore GC
8969 x_scroll_bar_note_movement (bar
, event
)
8970 struct scroll_bar
*bar
;
8973 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
8975 last_mouse_movement_time
= event
->xmotion
.time
;
8978 XSETVECTOR (last_mouse_scroll_bar
, bar
);
8980 /* If we're dragging the bar, display it. */
8981 if (! GC_NILP (bar
->dragging
))
8983 /* Where should the handle be now? */
8984 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
8986 if (new_start
!= XINT (bar
->start
))
8988 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8990 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8995 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8997 /* Return information to the user about the current position of the mouse
8998 on the scroll bar. */
9001 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
9003 Lisp_Object
*bar_window
;
9004 enum scroll_bar_part
*part
;
9006 unsigned long *time
;
9008 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
9009 Window w
= SCROLL_BAR_X_WINDOW (bar
);
9010 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
9012 Window dummy_window
;
9014 unsigned int dummy_mask
;
9018 /* Get the mouse's position relative to the scroll bar window, and
9020 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
9022 /* Root, child, root x and root y. */
9023 &dummy_window
, &dummy_window
,
9024 &dummy_coord
, &dummy_coord
,
9026 /* Position relative to scroll bar. */
9029 /* Mouse buttons and modifier keys. */
9036 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
9039 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
9041 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
9043 if (! NILP (bar
->dragging
))
9044 win_y
-= XINT (bar
->dragging
);
9048 if (win_y
> top_range
)
9052 *bar_window
= bar
->window
;
9054 if (! NILP (bar
->dragging
))
9055 *part
= scroll_bar_handle
;
9056 else if (win_y
< XINT (bar
->start
))
9057 *part
= scroll_bar_above_handle
;
9058 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
9059 *part
= scroll_bar_handle
;
9061 *part
= scroll_bar_below_handle
;
9063 XSETINT (*x
, win_y
);
9064 XSETINT (*y
, top_range
);
9067 last_mouse_scroll_bar
= Qnil
;
9070 *time
= last_mouse_movement_time
;
9076 /* The screen has been cleared so we may have changed foreground or
9077 background colors, and the scroll bars may need to be redrawn.
9078 Clear out the scroll bars, and ask for expose events, so we can
9082 x_scroll_bar_clear (f
)
9085 #ifndef USE_TOOLKIT_SCROLL_BARS
9088 /* We can have scroll bars even if this is 0,
9089 if we just turned off scroll bar mode.
9090 But in that case we should not clear them. */
9091 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
9092 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
9093 bar
= XSCROLL_BAR (bar
)->next
)
9094 XClearArea (FRAME_X_DISPLAY (f
),
9095 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
9097 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9100 /* This processes Expose events from the menu-bar specific X event
9101 loop in xmenu.c. This allows to redisplay the frame if necessary
9102 when handling menu-bar or pop-up items. */
9105 process_expose_from_menu (event
)
9109 struct x_display_info
*dpyinfo
;
9110 int frame_exposed_p
= 0;
9114 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
9115 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
9118 if (f
->async_visible
== 0)
9120 f
->async_visible
= 1;
9121 f
->async_iconified
= 0;
9122 f
->output_data
.x
->has_been_visible
= 1;
9123 SET_FRAME_GARBAGED (f
);
9127 expose_frame (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
9128 event
.xexpose
.x
, event
.xexpose
.y
,
9129 event
.xexpose
.width
, event
.xexpose
.height
);
9130 frame_exposed_p
= 1;
9135 struct scroll_bar
*bar
9136 = x_window_to_scroll_bar (event
.xexpose
.window
);
9139 x_scroll_bar_expose (bar
, &event
);
9143 return frame_exposed_p
;
9146 /* Define a queue to save up SelectionRequest events for later handling. */
9148 struct selection_event_queue
9151 struct selection_event_queue
*next
;
9154 static struct selection_event_queue
*queue
;
9156 /* Nonzero means queue up certain events--don't process them yet. */
9158 static int x_queue_selection_requests
;
9160 /* Queue up an X event *EVENT, to be processed later. */
9163 x_queue_event (f
, event
)
9167 struct selection_event_queue
*queue_tmp
9168 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
9170 if (queue_tmp
!= NULL
)
9172 queue_tmp
->event
= *event
;
9173 queue_tmp
->next
= queue
;
9178 /* Take all the queued events and put them back
9179 so that they get processed afresh. */
9182 x_unqueue_events (display
)
9185 while (queue
!= NULL
)
9187 struct selection_event_queue
*queue_tmp
= queue
;
9188 XPutBackEvent (display
, &queue_tmp
->event
);
9189 queue
= queue_tmp
->next
;
9190 xfree ((char *)queue_tmp
);
9194 /* Start queuing SelectionRequest events. */
9197 x_start_queuing_selection_requests (display
)
9200 x_queue_selection_requests
++;
9203 /* Stop queuing SelectionRequest events. */
9206 x_stop_queuing_selection_requests (display
)
9209 x_queue_selection_requests
--;
9210 x_unqueue_events (display
);
9213 /* The main X event-reading loop - XTread_socket. */
9215 /* Time stamp of enter window event. This is only used by XTread_socket,
9216 but we have to put it out here, since static variables within functions
9217 sometimes don't work. */
9219 static Time enter_timestamp
;
9221 /* This holds the state XLookupString needs to implement dead keys
9222 and other tricks known as "compose processing". _X Window System_
9223 says that a portable program can't use this, but Stephen Gildea assures
9224 me that letting the compiler initialize it to zeros will work okay.
9226 This must be defined outside of XTread_socket, for the same reasons
9227 given for enter_time stamp, above. */
9229 static XComposeStatus compose_status
;
9231 /* Record the last 100 characters stored
9232 to help debug the loss-of-chars-during-GC problem. */
9234 static int temp_index
;
9235 static short temp_buffer
[100];
9237 /* Set this to nonzero to fake an "X I/O error"
9238 on a particular display. */
9240 struct x_display_info
*XTread_socket_fake_io_error
;
9242 /* When we find no input here, we occasionally do a no-op command
9243 to verify that the X server is still running and we can still talk with it.
9244 We try all the open displays, one by one.
9245 This variable is used for cycling thru the displays. */
9247 static struct x_display_info
*next_noop_dpyinfo
;
9249 #define SET_SAVED_MENU_EVENT(size) \
9252 if (f->output_data.x->saved_menu_event == 0) \
9253 f->output_data.x->saved_menu_event \
9254 = (XEvent *) xmalloc (sizeof (XEvent)); \
9255 bcopy (&event, f->output_data.x->saved_menu_event, size); \
9256 if (numchars >= 1) \
9258 bufp->kind = menu_bar_activate_event; \
9259 XSETFRAME (bufp->frame_or_window, f); \
9268 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
9269 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
9271 /* Read events coming from the X server.
9272 This routine is called by the SIGIO handler.
9273 We return as soon as there are no more events to be read.
9275 Events representing keys are stored in buffer BUFP,
9276 which can hold up to NUMCHARS characters.
9277 We return the number of characters stored into the buffer,
9278 thus pretending to be `read'.
9280 EXPECTED is nonzero if the caller knows input is available. */
9283 XTread_socket (sd
, bufp
, numchars
, expected
)
9285 /* register */ struct input_event
*bufp
;
9286 /* register */ int numchars
;
9293 int event_found
= 0;
9294 struct x_display_info
*dpyinfo
;
9295 struct coding_system coding
;
9297 if (interrupt_input_blocked
)
9299 interrupt_input_pending
= 1;
9303 interrupt_input_pending
= 0;
9306 /* So people can tell when we have read the available input. */
9307 input_signal_count
++;
9310 abort (); /* Don't think this happens. */
9314 /* The input should be decoded if it is from XIM. Currently the
9315 locale of XIM is the same as that of the system. So, we can use
9316 Vlocale_coding_system which is initialized properly at Emacs
9318 setup_coding_system (Vlocale_coding_system
, &coding
);
9319 coding
.src_multibyte
= 0;
9320 coding
.dst_multibyte
= 1;
9321 /* The input is converted to events, thus we can't handle
9322 composition. Anyway, there's no XIM that gives us composition
9324 coding
.composing
= COMPOSITION_DISABLED
;
9326 /* Find the display we are supposed to read input for.
9327 It's the one communicating on descriptor SD. */
9328 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
9330 #if 0 /* This ought to be unnecessary; let's verify it. */
9332 /* If available, Xlib uses FIOSNBIO to make the socket
9333 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
9334 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
9335 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
9336 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
9337 #endif /* ! defined (FIOSNBIO) */
9340 #if 0 /* This code can't be made to work, with multiple displays,
9341 and appears not to be used on any system any more.
9342 Also keyboard.c doesn't turn O_NDELAY on and off
9343 for X connections. */
9346 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
9348 extern int read_alarm_should_throw
;
9349 read_alarm_should_throw
= 1;
9350 XPeekEvent (dpyinfo
->display
, &event
);
9351 read_alarm_should_throw
= 0;
9353 #endif /* HAVE_SELECT */
9357 /* For debugging, this gives a way to fake an I/O error. */
9358 if (dpyinfo
== XTread_socket_fake_io_error
)
9360 XTread_socket_fake_io_error
= 0;
9361 x_io_error_quitter (dpyinfo
->display
);
9364 while (XPending (dpyinfo
->display
))
9366 XNextEvent (dpyinfo
->display
, &event
);
9370 /* Filter events for the current X input method.
9371 XFilterEvent returns non-zero if the input method has
9372 consumed the event. We pass the frame's X window to
9373 XFilterEvent because that's the one for which the IC
9375 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
9376 event
.xclient
.window
);
9377 if (XFilterEvent (&event
, f1
? FRAME_X_WINDOW (f1
) : None
))
9387 if (event
.xclient
.message_type
9388 == dpyinfo
->Xatom_wm_protocols
9389 && event
.xclient
.format
== 32)
9391 if (event
.xclient
.data
.l
[0]
9392 == dpyinfo
->Xatom_wm_take_focus
)
9394 /* Use x_any_window_to_frame because this
9395 could be the shell widget window
9396 if the frame has no title bar. */
9397 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
9399 /* Not quite sure this is needed -pd */
9400 if (f
&& FRAME_XIC (f
))
9401 XSetICFocus (FRAME_XIC (f
));
9403 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
9404 instructs the WM to set the input focus automatically for
9405 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
9406 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
9407 it has set the focus. So, XSetInputFocus below is not
9410 The call to XSetInputFocus below has also caused trouble. In
9411 cases where the XSetInputFocus done by the WM and the one
9412 below are temporally close (on a fast machine), the call
9413 below can generate additional FocusIn events which confuse
9416 /* Since we set WM_TAKE_FOCUS, we must call
9417 XSetInputFocus explicitly. But not if f is null,
9418 since that might be an event for a deleted frame. */
9421 Display
*d
= event
.xclient
.display
;
9422 /* Catch and ignore errors, in case window has been
9423 iconified by a window manager such as GWM. */
9424 int count
= x_catch_errors (d
);
9425 XSetInputFocus (d
, event
.xclient
.window
,
9426 /* The ICCCM says this is
9427 the only valid choice. */
9429 event
.xclient
.data
.l
[1]);
9430 /* This is needed to detect the error
9431 if there is an error. */
9433 x_uncatch_errors (d
, count
);
9435 /* Not certain about handling scroll bars here */
9438 else if (event
.xclient
.data
.l
[0]
9439 == dpyinfo
->Xatom_wm_save_yourself
)
9441 /* Save state modify the WM_COMMAND property to
9442 something which can reinstate us. This notifies
9443 the session manager, who's looking for such a
9444 PropertyNotify. Can restart processing when
9445 a keyboard or mouse event arrives. */
9448 f
= x_top_window_to_frame (dpyinfo
,
9449 event
.xclient
.window
);
9451 /* This is just so we only give real data once
9452 for a single Emacs process. */
9453 if (f
== SELECTED_FRAME ())
9454 XSetCommand (FRAME_X_DISPLAY (f
),
9455 event
.xclient
.window
,
9456 initial_argv
, initial_argc
);
9458 XSetCommand (FRAME_X_DISPLAY (f
),
9459 event
.xclient
.window
,
9463 else if (event
.xclient
.data
.l
[0]
9464 == dpyinfo
->Xatom_wm_delete_window
)
9467 = x_any_window_to_frame (dpyinfo
,
9468 event
.xclient
.window
);
9475 bufp
->kind
= delete_window_event
;
9476 XSETFRAME (bufp
->frame_or_window
, f
);
9485 else if (event
.xclient
.message_type
9486 == dpyinfo
->Xatom_wm_configure_denied
)
9489 else if (event
.xclient
.message_type
9490 == dpyinfo
->Xatom_wm_window_moved
)
9494 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9496 new_x
= event
.xclient
.data
.s
[0];
9497 new_y
= event
.xclient
.data
.s
[1];
9501 f
->output_data
.x
->left_pos
= new_x
;
9502 f
->output_data
.x
->top_pos
= new_y
;
9506 else if (event
.xclient
.message_type
9507 == dpyinfo
->Xatom_editres
)
9510 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
9511 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
9514 #endif /* HACK_EDITRES */
9515 else if ((event
.xclient
.message_type
9516 == dpyinfo
->Xatom_DONE
)
9517 || (event
.xclient
.message_type
9518 == dpyinfo
->Xatom_PAGE
))
9520 /* Ghostview job completed. Kill it. We could
9521 reply with "Next" if we received "Page", but we
9522 currently never do because we are interested in
9523 images, only, which should have 1 page. */
9524 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
9526 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9527 x_kill_gs_process (pixmap
, f
);
9528 expose_frame (f
, 0, 0, 0, 0);
9530 #ifdef USE_TOOLKIT_SCROLL_BARS
9531 /* Scroll bar callbacks send a ClientMessage from which
9532 we construct an input_event. */
9533 else if (event
.xclient
.message_type
9534 == dpyinfo
->Xatom_Scrollbar
)
9536 x_scroll_bar_to_input_event (&event
, bufp
);
9537 ++bufp
, ++count
, --numchars
;
9540 #endif /* USE_TOOLKIT_SCROLL_BARS */
9546 case SelectionNotify
:
9547 #ifdef USE_X_TOOLKIT
9548 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
9550 #endif /* not USE_X_TOOLKIT */
9551 x_handle_selection_notify (&event
.xselection
);
9554 case SelectionClear
: /* Someone has grabbed ownership. */
9555 #ifdef USE_X_TOOLKIT
9556 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
9558 #endif /* USE_X_TOOLKIT */
9560 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
9565 bufp
->kind
= selection_clear_event
;
9566 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
9567 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
9568 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
9569 bufp
->frame_or_window
= Qnil
;
9578 case SelectionRequest
: /* Someone wants our selection. */
9579 #ifdef USE_X_TOOLKIT
9580 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
9582 #endif /* USE_X_TOOLKIT */
9583 if (x_queue_selection_requests
)
9584 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
9588 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
9593 bufp
->kind
= selection_request_event
;
9594 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
9595 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
9596 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
9597 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
9598 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
9599 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
9600 bufp
->frame_or_window
= Qnil
;
9609 case PropertyNotify
:
9610 #ifdef USE_X_TOOLKIT
9611 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
9613 #endif /* not USE_X_TOOLKIT */
9614 x_handle_property_notify (&event
.xproperty
);
9617 case ReparentNotify
:
9618 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
9622 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
9623 x_real_positions (f
, &x
, &y
);
9624 f
->output_data
.x
->left_pos
= x
;
9625 f
->output_data
.x
->top_pos
= y
;
9630 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
9633 if (f
->async_visible
== 0)
9635 f
->async_visible
= 1;
9636 f
->async_iconified
= 0;
9637 f
->output_data
.x
->has_been_visible
= 1;
9638 SET_FRAME_GARBAGED (f
);
9641 expose_frame (x_window_to_frame (dpyinfo
,
9642 event
.xexpose
.window
),
9643 event
.xexpose
.x
, event
.xexpose
.y
,
9644 event
.xexpose
.width
, event
.xexpose
.height
);
9648 #ifdef USE_TOOLKIT_SCROLL_BARS
9649 /* Dispatch event to the widget. */
9651 #else /* not USE_TOOLKIT_SCROLL_BARS */
9652 struct scroll_bar
*bar
9653 = x_window_to_scroll_bar (event
.xexpose
.window
);
9656 x_scroll_bar_expose (bar
, &event
);
9657 #ifdef USE_X_TOOLKIT
9660 #endif /* USE_X_TOOLKIT */
9661 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9665 case GraphicsExpose
: /* This occurs when an XCopyArea's
9666 source area was obscured or not
9668 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
9672 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
9673 event
.xgraphicsexpose
.width
,
9674 event
.xgraphicsexpose
.height
);
9676 #ifdef USE_X_TOOLKIT
9679 #endif /* USE_X_TOOLKIT */
9682 case NoExpose
: /* This occurs when an XCopyArea's
9683 source area was completely
9688 /* Redo the mouse-highlight after the tooltip has gone. */
9689 if (event
.xmap
.window
== tip_window
)
9692 redo_mouse_highlight ();
9695 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
9696 if (f
) /* F may no longer exist if
9697 the frame was deleted. */
9699 /* While a frame is unmapped, display generation is
9700 disabled; you don't want to spend time updating a
9701 display that won't ever be seen. */
9702 f
->async_visible
= 0;
9703 /* We can't distinguish, from the event, whether the window
9704 has become iconified or invisible. So assume, if it
9705 was previously visible, than now it is iconified.
9706 But x_make_frame_invisible clears both
9707 the visible flag and the iconified flag;
9708 and that way, we know the window is not iconified now. */
9709 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
9711 f
->async_iconified
= 1;
9713 bufp
->kind
= iconify_event
;
9714 XSETFRAME (bufp
->frame_or_window
, f
);
9724 if (event
.xmap
.window
== tip_window
)
9725 /* The tooltip has been drawn already. Avoid
9726 the SET_FRAME_GARBAGED below. */
9729 /* We use x_top_window_to_frame because map events can
9730 come for sub-windows and they don't mean that the
9731 frame is visible. */
9732 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
9735 f
->async_visible
= 1;
9736 f
->async_iconified
= 0;
9737 f
->output_data
.x
->has_been_visible
= 1;
9739 /* wait_reading_process_input will notice this and update
9740 the frame's display structures. */
9741 SET_FRAME_GARBAGED (f
);
9745 bufp
->kind
= deiconify_event
;
9746 XSETFRAME (bufp
->frame_or_window
, f
);
9752 else if (! NILP (Vframe_list
)
9753 && ! NILP (XCDR (Vframe_list
)))
9754 /* Force a redisplay sooner or later
9755 to update the frame titles
9756 in case this is the second frame. */
9757 record_asynch_buffer_change ();
9762 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
9764 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
9765 /* I couldn't find a way to prevent LessTif scroll bars
9766 from consuming key events. */
9769 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
9771 if (widget
&& XmIsScrollBar (widget
))
9773 widget
= XtParent (widget
);
9774 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
9777 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
9781 KeySym keysym
, orig_keysym
;
9782 /* al%imercury@uunet.uu.net says that making this 81
9783 instead of 80 fixed a bug whereby meta chars made
9786 It seems that some version of XmbLookupString has
9787 a bug of not returning XBufferOverflow in
9788 status_return even if the input is too long to
9789 fit in 81 bytes. So, we must prepare sufficient
9790 bytes for copy_buffer. 513 bytes (256 chars for
9791 two-byte character set) seems to be a faily good
9792 approximation. -- 2000.8.10 handa@etl.go.jp */
9793 unsigned char copy_buffer
[513];
9794 unsigned char *copy_bufptr
= copy_buffer
;
9795 int copy_bufsiz
= sizeof (copy_buffer
);
9799 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
9800 extra_keyboard_modifiers
);
9801 modifiers
= event
.xkey
.state
;
9803 /* This will have to go some day... */
9805 /* make_lispy_event turns chars into control chars.
9806 Don't do it here because XLookupString is too eager. */
9807 event
.xkey
.state
&= ~ControlMask
;
9808 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
9809 | dpyinfo
->super_mod_mask
9810 | dpyinfo
->hyper_mod_mask
9811 | dpyinfo
->alt_mod_mask
);
9813 /* In case Meta is ComposeCharacter,
9814 clear its status. According to Markus Ehrnsperger
9815 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
9816 this enables ComposeCharacter to work whether or
9817 not it is combined with Meta. */
9818 if (modifiers
& dpyinfo
->meta_mod_mask
)
9819 bzero (&compose_status
, sizeof (compose_status
));
9824 Status status_return
;
9826 nbytes
= XmbLookupString (FRAME_XIC (f
),
9827 &event
.xkey
, copy_bufptr
,
9828 copy_bufsiz
, &keysym
,
9830 if (status_return
== XBufferOverflow
)
9832 copy_bufsiz
= nbytes
+ 1;
9833 copy_bufptr
= (char *) alloca (copy_bufsiz
);
9834 nbytes
= XmbLookupString (FRAME_XIC (f
),
9835 &event
.xkey
, copy_bufptr
,
9836 copy_bufsiz
, &keysym
,
9840 if (status_return
== XLookupNone
)
9842 else if (status_return
== XLookupChars
)
9847 else if (status_return
!= XLookupKeySym
9848 && status_return
!= XLookupBoth
)
9852 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
9853 copy_bufsiz
, &keysym
,
9856 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
9857 copy_bufsiz
, &keysym
,
9861 orig_keysym
= keysym
;
9865 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
9866 || keysym
== XK_Delete
9867 #ifdef XK_ISO_Left_Tab
9868 || (keysym
>= XK_ISO_Left_Tab
&& keysym
<= XK_ISO_Enter
)
9870 || (keysym
>= XK_Kanji
&& keysym
<= XK_Eisu_toggle
)
9871 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
9872 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
9874 /* This recognizes the "extended function keys".
9875 It seems there's no cleaner way.
9876 Test IsModifierKey to avoid handling mode_switch
9878 || ((unsigned) (keysym
) >= XK_Select
9879 && (unsigned)(keysym
) < XK_KP_Space
)
9881 #ifdef XK_dead_circumflex
9882 || orig_keysym
== XK_dead_circumflex
9884 #ifdef XK_dead_grave
9885 || orig_keysym
== XK_dead_grave
9887 #ifdef XK_dead_tilde
9888 || orig_keysym
== XK_dead_tilde
9890 #ifdef XK_dead_diaeresis
9891 || orig_keysym
== XK_dead_diaeresis
9893 #ifdef XK_dead_macron
9894 || orig_keysym
== XK_dead_macron
9896 #ifdef XK_dead_degree
9897 || orig_keysym
== XK_dead_degree
9899 #ifdef XK_dead_acute
9900 || orig_keysym
== XK_dead_acute
9902 #ifdef XK_dead_cedilla
9903 || orig_keysym
== XK_dead_cedilla
9905 #ifdef XK_dead_breve
9906 || orig_keysym
== XK_dead_breve
9908 #ifdef XK_dead_ogonek
9909 || orig_keysym
== XK_dead_ogonek
9911 #ifdef XK_dead_caron
9912 || orig_keysym
== XK_dead_caron
9914 #ifdef XK_dead_doubleacute
9915 || orig_keysym
== XK_dead_doubleacute
9917 #ifdef XK_dead_abovedot
9918 || orig_keysym
== XK_dead_abovedot
9920 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
9921 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
9922 /* Any "vendor-specific" key is ok. */
9923 || (orig_keysym
& (1 << 28)))
9924 && ! (IsModifierKey (orig_keysym
)
9926 #ifdef XK_Mode_switch
9927 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
9930 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
9932 #endif /* not HAVE_X11R5 */
9935 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
9937 temp_buffer
[temp_index
++] = keysym
;
9938 bufp
->kind
= non_ascii_keystroke
;
9939 bufp
->code
= keysym
;
9940 XSETFRAME (bufp
->frame_or_window
, f
);
9943 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
9945 bufp
->timestamp
= event
.xkey
.time
;
9950 else if (numchars
> nbytes
)
9956 for (i
= 0; i
< nbytes
; i
++)
9958 if (temp_index
== (sizeof temp_buffer
9961 temp_buffer
[temp_index
++] = copy_bufptr
[i
];
9964 if (/* If the event is not from XIM, */
9965 event
.xkey
.keycode
!= 0
9966 /* or the current locale doesn't request
9967 decoding of the intup data, ... */
9968 || coding
.type
== coding_type_raw_text
9969 || coding
.type
== coding_type_no_conversion
)
9971 /* ... we can use the input data as is. */
9976 /* We have to decode the input data. */
9980 require
= decoding_buffer_size (&coding
, nbytes
);
9981 p
= (unsigned char *) alloca (require
);
9982 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
9983 decode_coding (&coding
, copy_bufptr
, p
,
9985 nbytes
= coding
.produced
;
9986 nchars
= coding
.produced_char
;
9990 /* Convert the input data to a sequence of
9991 character events. */
9992 for (i
= 0; i
< nbytes
; i
+= len
)
9994 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
9996 bufp
->kind
= (SINGLE_BYTE_CHAR_P (c
)
9998 : multibyte_char_keystroke
);
10000 XSETFRAME (bufp
->frame_or_window
, f
);
10003 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
10005 bufp
->timestamp
= event
.xkey
.time
;
10010 numchars
-= nchars
;
10012 if (keysym
== NoSymbol
)
10022 /* Don't dispatch this event since XtDispatchEvent calls
10023 XFilterEvent, and two calls in a row may freeze the
10032 /* Don't dispatch this event since XtDispatchEvent calls
10033 XFilterEvent, and two calls in a row may freeze the
10040 /* Here's a possible interpretation of the whole
10041 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If
10042 you get a FocusIn event, you have to get a FocusOut
10043 event before you relinquish the focus. If you
10044 haven't received a FocusIn event, then a mere
10045 LeaveNotify is enough to free you. */
10049 int from_menu_bar_p
= 0;
10051 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10053 #ifdef LESSTIF_VERSION
10054 /* When clicking outside of a menu bar popup to close
10055 it, we get a FocusIn/ EnterNotify sequence of
10056 events. The flag event.xcrossing.focus is not set
10057 in the EnterNotify event of that sequence because
10058 the focus is in the menu bar,
10059 event.xcrossing.window is the frame's X window.
10060 Unconditionally setting the focus frame to null in
10061 this case is not the right thing, because no event
10062 follows that could set the focus frame to the right
10065 This could be a LessTif bug, but I wasn't able to
10066 reproduce the behavior in a simple test program.
10067 On the other hand, Motif seems to not have this
10070 (gerd, LessTif 0.92). */
10072 if (!event
.xcrossing
.focus
10074 && f
->output_data
.x
->menubar_widget
)
10079 XGetInputFocus (FRAME_X_DISPLAY (f
), &focus
, &revert
);
10080 if (focus
== XtWindow (f
->output_data
.x
->menubar_widget
))
10081 from_menu_bar_p
= 1;
10083 #endif /* LESSTIF_VERSION */
10085 if (event
.xcrossing
.focus
|| from_menu_bar_p
)
10087 /* Avoid nasty pop/raise loops. */
10088 if (f
&& (!(f
->auto_raise
)
10089 || !(f
->auto_lower
)
10090 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
10092 x_new_focus_frame (dpyinfo
, f
);
10093 enter_timestamp
= event
.xcrossing
.time
;
10096 else if (f
== dpyinfo
->x_focus_frame
)
10097 x_new_focus_frame (dpyinfo
, 0);
10099 /* EnterNotify counts as mouse movement,
10100 so update things that depend on mouse position. */
10101 if (f
&& !f
->output_data
.x
->hourglass_p
)
10102 note_mouse_movement (f
, &event
.xmotion
);
10107 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
10108 if (event
.xfocus
.detail
!= NotifyPointer
)
10109 dpyinfo
->x_focus_event_frame
= f
;
10112 x_new_focus_frame (dpyinfo
, f
);
10114 /* Don't stop displaying the initial startup message
10115 for a switch-frame event we don't need. */
10116 if (GC_NILP (Vterminal_frame
)
10117 && GC_CONSP (Vframe_list
)
10118 && !GC_NILP (XCDR (Vframe_list
)))
10120 bufp
->kind
= FOCUS_IN_EVENT
;
10121 XSETFRAME (bufp
->frame_or_window
, f
);
10123 ++bufp
, ++count
, --numchars
;
10128 if (f
&& FRAME_XIC (f
))
10129 XSetICFocus (FRAME_XIC (f
));
10135 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
10138 int from_menu_bar_p
= 0;
10140 if (f
== dpyinfo
->mouse_face_mouse_frame
)
10142 /* If we move outside the frame, then we're
10143 certainly no longer on any text in the frame. */
10144 clear_mouse_face (dpyinfo
);
10145 dpyinfo
->mouse_face_mouse_frame
= 0;
10148 /* Generate a nil HELP_EVENT to cancel a help-echo.
10149 Do it only if there's something to cancel.
10150 Otherwise, the startup message is cleared when
10151 the mouse leaves the frame. */
10152 if (any_help_event_p
)
10157 XSETFRAME (frame
, f
);
10159 n
= gen_help_event (bufp
, numchars
,
10160 Qnil
, frame
, Qnil
, Qnil
, 0);
10161 bufp
+= n
, count
+= n
, numchars
-= n
;
10164 #ifdef LESSTIF_VERSION
10165 /* Please see the comment at the start of the
10166 EnterNotify case. */
10167 if (!event
.xcrossing
.focus
10168 && f
->output_data
.x
->menubar_widget
)
10172 XGetInputFocus (FRAME_X_DISPLAY (f
), &focus
, &revert
);
10173 if (focus
== XtWindow (f
->output_data
.x
->menubar_widget
))
10174 from_menu_bar_p
= 1;
10176 #endif /* LESSTIF_VERSION */
10178 if (event
.xcrossing
.focus
|| from_menu_bar_p
)
10179 x_mouse_leave (dpyinfo
);
10182 if (f
== dpyinfo
->x_focus_event_frame
)
10183 dpyinfo
->x_focus_event_frame
= 0;
10184 if (f
== dpyinfo
->x_focus_frame
)
10185 x_new_focus_frame (dpyinfo
, 0);
10191 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
10192 if (event
.xfocus
.detail
!= NotifyPointer
10193 && f
== dpyinfo
->x_focus_event_frame
)
10194 dpyinfo
->x_focus_event_frame
= 0;
10195 if (f
&& f
== dpyinfo
->x_focus_frame
)
10196 x_new_focus_frame (dpyinfo
, 0);
10199 if (f
&& FRAME_XIC (f
))
10200 XUnsetICFocus (FRAME_XIC (f
));
10207 previous_help_echo
= help_echo
;
10208 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
10209 help_echo_pos
= -1;
10211 if (dpyinfo
->grabbed
&& last_mouse_frame
10212 && FRAME_LIVE_P (last_mouse_frame
))
10213 f
= last_mouse_frame
;
10215 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
10218 note_mouse_movement (f
, &event
.xmotion
);
10221 #ifndef USE_TOOLKIT_SCROLL_BARS
10222 struct scroll_bar
*bar
10223 = x_window_to_scroll_bar (event
.xmotion
.window
);
10226 x_scroll_bar_note_movement (bar
, &event
);
10227 #endif /* USE_TOOLKIT_SCROLL_BARS */
10229 /* If we move outside the frame, then we're
10230 certainly no longer on any text in the frame. */
10231 clear_mouse_face (dpyinfo
);
10234 /* If the contents of the global variable help_echo
10235 has changed, generate a HELP_EVENT. */
10236 if (!NILP (help_echo
)
10237 || !NILP (previous_help_echo
))
10243 XSETFRAME (frame
, f
);
10247 any_help_event_p
= 1;
10248 n
= gen_help_event (bufp
, numchars
, help_echo
, frame
,
10249 help_echo_window
, help_echo_object
,
10251 bufp
+= n
, count
+= n
, numchars
-= n
;
10257 case ConfigureNotify
:
10258 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
10261 #ifndef USE_X_TOOLKIT
10262 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
10263 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
10265 /* In the toolkit version, change_frame_size
10266 is called by the code that handles resizing
10267 of the EmacsFrame widget. */
10269 /* Even if the number of character rows and columns has
10270 not changed, the font size may have changed, so we need
10271 to check the pixel dimensions as well. */
10272 if (columns
!= f
->width
10273 || rows
!= f
->height
10274 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
10275 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
10277 change_frame_size (f
, rows
, columns
, 0, 1, 0);
10278 SET_FRAME_GARBAGED (f
);
10279 cancel_mouse_face (f
);
10283 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
10284 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
10286 /* What we have now is the position of Emacs's own window.
10287 Convert that to the position of the window manager window. */
10288 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
10289 &f
->output_data
.x
->top_pos
);
10292 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
10293 xic_set_statusarea (f
);
10296 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
10298 /* Since the WM decorations come below top_pos now,
10299 we must put them below top_pos in the future. */
10300 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
10301 x_wm_set_size_hint (f
, (long) 0, 0);
10304 /* Some window managers pass (0,0) as the location of
10305 the window, and the Motif event handler stores it
10306 in the emacs widget, which messes up Motif menus. */
10307 if (event
.xconfigure
.x
== 0 && event
.xconfigure
.y
== 0)
10309 event
.xconfigure
.x
= f
->output_data
.x
->widget
->core
.x
;
10310 event
.xconfigure
.y
= f
->output_data
.x
->widget
->core
.y
;
10312 #endif /* USE_MOTIF */
10317 case ButtonRelease
:
10319 /* If we decide we want to generate an event to be seen
10320 by the rest of Emacs, we put it here. */
10321 struct input_event emacs_event
;
10322 int tool_bar_p
= 0;
10324 emacs_event
.kind
= no_event
;
10325 bzero (&compose_status
, sizeof (compose_status
));
10327 if (dpyinfo
->grabbed
10328 && last_mouse_frame
10329 && FRAME_LIVE_P (last_mouse_frame
))
10330 f
= last_mouse_frame
;
10332 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
10336 /* Is this in the tool-bar? */
10337 if (WINDOWP (f
->tool_bar_window
)
10338 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
10340 Lisp_Object window
;
10343 x
= event
.xbutton
.x
;
10344 y
= event
.xbutton
.y
;
10347 window
= window_from_coordinates (f
, x
, y
, &p
, 1);
10348 if (EQ (window
, f
->tool_bar_window
))
10350 x_handle_tool_bar_click (f
, &event
.xbutton
);
10356 if (!dpyinfo
->x_focus_frame
10357 || f
== dpyinfo
->x_focus_frame
)
10358 construct_mouse_click (&emacs_event
, &event
, f
);
10362 #ifndef USE_TOOLKIT_SCROLL_BARS
10363 struct scroll_bar
*bar
10364 = x_window_to_scroll_bar (event
.xbutton
.window
);
10367 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
10368 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10371 if (event
.type
== ButtonPress
)
10373 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
10374 last_mouse_frame
= f
;
10375 /* Ignore any mouse motion that happened
10376 before this event; any subsequent mouse-movement
10377 Emacs events should reflect only motion after
10378 the ButtonPress. */
10380 f
->mouse_moved
= 0;
10383 last_tool_bar_item
= -1;
10387 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
10390 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
10392 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
10398 #ifdef USE_X_TOOLKIT
10399 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
10400 /* For a down-event in the menu bar,
10401 don't pass it to Xt right now.
10402 Instead, save it away
10403 and we will pass it to Xt from kbd_buffer_get_event.
10404 That way, we can run some Lisp code first. */
10405 if (f
&& event
.type
== ButtonPress
10406 /* Verify the event is really within the menu bar
10407 and not just sent to it due to grabbing. */
10408 && event
.xbutton
.x
>= 0
10409 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
10410 && event
.xbutton
.y
>= 0
10411 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
10412 && event
.xbutton
.same_screen
)
10414 SET_SAVED_BUTTON_EVENT
;
10415 XSETFRAME (last_mouse_press_frame
, f
);
10417 else if (event
.type
== ButtonPress
)
10419 last_mouse_press_frame
= Qnil
;
10423 #ifdef USE_MOTIF /* This should do not harm for Lucid,
10424 but I am trying to be cautious. */
10425 else if (event
.type
== ButtonRelease
)
10427 if (!NILP (last_mouse_press_frame
))
10429 f
= XFRAME (last_mouse_press_frame
);
10430 if (f
->output_data
.x
)
10431 SET_SAVED_BUTTON_EVENT
;
10436 #endif /* USE_MOTIF */
10439 #endif /* USE_X_TOOLKIT */
10443 case CirculateNotify
:
10446 case CirculateRequest
:
10449 case VisibilityNotify
:
10452 case MappingNotify
:
10453 /* Someone has changed the keyboard mapping - update the
10455 switch (event
.xmapping
.request
)
10457 case MappingModifier
:
10458 x_find_modifier_meanings (dpyinfo
);
10459 /* This is meant to fall through. */
10460 case MappingKeyboard
:
10461 XRefreshKeyboardMapping (&event
.xmapping
);
10467 #ifdef USE_X_TOOLKIT
10469 XtDispatchEvent (&event
);
10471 #endif /* USE_X_TOOLKIT */
10479 /* On some systems, an X bug causes Emacs to get no more events
10480 when the window is destroyed. Detect that. (1994.) */
10483 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
10484 One XNOOP in 100 loops will make Emacs terminate.
10485 B. Bretthauer, 1994 */
10487 if (x_noop_count
>= 100)
10491 if (next_noop_dpyinfo
== 0)
10492 next_noop_dpyinfo
= x_display_list
;
10494 XNoOp (next_noop_dpyinfo
->display
);
10496 /* Each time we get here, cycle through the displays now open. */
10497 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
10501 /* If the focus was just given to an auto-raising frame,
10503 /* ??? This ought to be able to handle more than one such frame. */
10504 if (pending_autoraise_frame
)
10506 x_raise_frame (pending_autoraise_frame
);
10507 pending_autoraise_frame
= 0;
10518 /***********************************************************************
10520 ***********************************************************************/
10522 /* Note if the text cursor of window W has been overwritten by a
10523 drawing operation that outputs N glyphs starting at HPOS in the
10524 line given by output_cursor.vpos. N < 0 means all the rest of the
10525 line after HPOS has been written. */
10528 note_overwritten_text_cursor (w
, hpos
, n
)
10532 if (updated_area
== TEXT_AREA
10533 && output_cursor
.vpos
== w
->phys_cursor
.vpos
10534 && hpos
<= w
->phys_cursor
.hpos
10536 || hpos
+ n
> w
->phys_cursor
.hpos
))
10537 w
->phys_cursor_on_p
= 0;
10541 /* Set clipping for output in glyph row ROW. W is the window in which
10542 we operate. GC is the graphics context to set clipping in.
10543 WHOLE_LINE_P non-zero means include the areas used for truncation
10544 mark display and alike in the clipping rectangle.
10546 ROW may be a text row or, e.g., a mode line. Text rows must be
10547 clipped to the interior of the window dedicated to text display,
10548 mode lines must be clipped to the whole window. */
10551 x_clip_to_row (w
, row
, gc
, whole_line_p
)
10553 struct glyph_row
*row
;
10557 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10558 XRectangle clip_rect
;
10559 int window_x
, window_y
, window_width
, window_height
;
10561 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
10563 clip_rect
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
10564 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
10565 clip_rect
.y
= max (clip_rect
.y
, window_y
);
10566 clip_rect
.width
= window_width
;
10567 clip_rect
.height
= row
->visible_height
;
10569 /* If clipping to the whole line, including trunc marks, extend
10570 the rectangle to the left and increase its width. */
10573 clip_rect
.x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
10574 clip_rect
.width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
10577 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
10581 /* Draw a hollow box cursor on window W in glyph row ROW. */
10584 x_draw_hollow_cursor (w
, row
)
10586 struct glyph_row
*row
;
10588 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10589 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10590 Display
*dpy
= FRAME_X_DISPLAY (f
);
10593 struct glyph
*cursor_glyph
;
10596 /* Compute frame-relative coordinates from window-relative
10598 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
10599 y
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
10600 + row
->ascent
- w
->phys_cursor_ascent
);
10601 h
= row
->height
- 1;
10603 /* Get the glyph the cursor is on. If we can't tell because
10604 the current matrix is invalid or such, give up. */
10605 cursor_glyph
= get_phys_cursor_glyph (w
);
10606 if (cursor_glyph
== NULL
)
10609 /* Compute the width of the rectangle to draw. If on a stretch
10610 glyph, and `x-stretch-block-cursor' is nil, don't draw a
10611 rectangle as wide as the glyph, but use a canonical character
10613 wd
= cursor_glyph
->pixel_width
- 1;
10614 if (cursor_glyph
->type
== STRETCH_GLYPH
10615 && !x_stretch_cursor_p
)
10616 wd
= min (CANON_X_UNIT (f
), wd
);
10618 /* The foreground of cursor_gc is typically the same as the normal
10619 background color, which can cause the cursor box to be invisible. */
10620 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
10621 if (dpyinfo
->scratch_cursor_gc
)
10622 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
10624 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
10625 GCForeground
, &xgcv
);
10626 gc
= dpyinfo
->scratch_cursor_gc
;
10628 /* Set clipping, draw the rectangle, and reset clipping again. */
10629 x_clip_to_row (w
, row
, gc
, 0);
10630 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
10631 XSetClipMask (dpy
, gc
, None
);
10635 /* Draw a bar cursor on window W in glyph row ROW.
10637 Implementation note: One would like to draw a bar cursor with an
10638 angle equal to the one given by the font property XA_ITALIC_ANGLE.
10639 Unfortunately, I didn't find a font yet that has this property set.
10643 x_draw_bar_cursor (w
, row
, width
)
10645 struct glyph_row
*row
;
10648 struct frame
*f
= XFRAME (w
->frame
);
10649 struct glyph
*cursor_glyph
;
10652 unsigned long mask
;
10657 /* If cursor is out of bounds, don't draw garbage. This can happen
10658 in mini-buffer windows when switching between echo area glyphs
10659 and mini-buffer. */
10660 cursor_glyph
= get_phys_cursor_glyph (w
);
10661 if (cursor_glyph
== NULL
)
10664 /* If on an image, draw like a normal cursor. That's usually better
10665 visible than drawing a bar, esp. if the image is large so that
10666 the bar might not be in the window. */
10667 if (cursor_glyph
->type
== IMAGE_GLYPH
)
10669 struct glyph_row
*row
;
10670 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
10671 x_draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
10675 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
10676 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
10677 xgcv
.graphics_exposures
= 0;
10678 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
10679 dpy
= FRAME_X_DISPLAY (f
);
10680 window
= FRAME_X_WINDOW (f
);
10681 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
10684 XChangeGC (dpy
, gc
, mask
, &xgcv
);
10687 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
10688 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
10692 width
= f
->output_data
.x
->cursor_width
;
10694 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
10695 x_clip_to_row (w
, row
, gc
, 0);
10696 XFillRectangle (dpy
, window
, gc
,
10698 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
10699 min (cursor_glyph
->pixel_width
, width
),
10701 XSetClipMask (dpy
, gc
, None
);
10706 /* Clear the cursor of window W to background color, and mark the
10707 cursor as not shown. This is used when the text where the cursor
10708 is is about to be rewritten. */
10714 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
10715 x_update_window_cursor (w
, 0);
10719 /* Draw the cursor glyph of window W in glyph row ROW. See the
10720 comment of x_draw_glyphs for the meaning of HL. */
10723 x_draw_phys_cursor_glyph (w
, row
, hl
)
10725 struct glyph_row
*row
;
10726 enum draw_glyphs_face hl
;
10728 /* If cursor hpos is out of bounds, don't draw garbage. This can
10729 happen in mini-buffer windows when switching between echo area
10730 glyphs and mini-buffer. */
10731 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
10733 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
10734 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
10737 /* When we erase the cursor, and ROW is overlapped by other
10738 rows, make sure that these overlapping parts of other rows
10740 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
10742 if (row
> w
->current_matrix
->rows
10743 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
10744 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
10746 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
10747 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
10748 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
10754 /* Erase the image of a cursor of window W from the screen. */
10757 x_erase_phys_cursor (w
)
10760 struct frame
*f
= XFRAME (w
->frame
);
10761 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10762 int hpos
= w
->phys_cursor
.hpos
;
10763 int vpos
= w
->phys_cursor
.vpos
;
10764 int mouse_face_here_p
= 0;
10765 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
10766 struct glyph_row
*cursor_row
;
10767 struct glyph
*cursor_glyph
;
10768 enum draw_glyphs_face hl
;
10770 /* No cursor displayed or row invalidated => nothing to do on the
10772 if (w
->phys_cursor_type
== NO_CURSOR
)
10773 goto mark_cursor_off
;
10775 /* VPOS >= active_glyphs->nrows means that window has been resized.
10776 Don't bother to erase the cursor. */
10777 if (vpos
>= active_glyphs
->nrows
)
10778 goto mark_cursor_off
;
10780 /* If row containing cursor is marked invalid, there is nothing we
10782 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
10783 if (!cursor_row
->enabled_p
)
10784 goto mark_cursor_off
;
10786 /* This can happen when the new row is shorter than the old one.
10787 In this case, either x_draw_glyphs or clear_end_of_line
10788 should have cleared the cursor. Note that we wouldn't be
10789 able to erase the cursor in this case because we don't have a
10790 cursor glyph at hand. */
10791 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
10792 goto mark_cursor_off
;
10794 /* If the cursor is in the mouse face area, redisplay that when
10795 we clear the cursor. */
10796 if (! NILP (dpyinfo
->mouse_face_window
)
10797 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
10798 && (vpos
> dpyinfo
->mouse_face_beg_row
10799 || (vpos
== dpyinfo
->mouse_face_beg_row
10800 && hpos
>= dpyinfo
->mouse_face_beg_col
))
10801 && (vpos
< dpyinfo
->mouse_face_end_row
10802 || (vpos
== dpyinfo
->mouse_face_end_row
10803 && hpos
< dpyinfo
->mouse_face_end_col
))
10804 /* Don't redraw the cursor's spot in mouse face if it is at the
10805 end of a line (on a newline). The cursor appears there, but
10806 mouse highlighting does not. */
10807 && cursor_row
->used
[TEXT_AREA
] > hpos
)
10808 mouse_face_here_p
= 1;
10810 /* Maybe clear the display under the cursor. */
10811 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
10814 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
10816 cursor_glyph
= get_phys_cursor_glyph (w
);
10817 if (cursor_glyph
== NULL
)
10818 goto mark_cursor_off
;
10820 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
10822 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10824 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
10826 cursor_glyph
->pixel_width
,
10827 cursor_row
->visible_height
,
10831 /* Erase the cursor by redrawing the character underneath it. */
10832 if (mouse_face_here_p
)
10833 hl
= DRAW_MOUSE_FACE
;
10834 else if (cursor_row
->inverse_p
)
10835 hl
= DRAW_INVERSE_VIDEO
;
10837 hl
= DRAW_NORMAL_TEXT
;
10838 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
10841 w
->phys_cursor_on_p
= 0;
10842 w
->phys_cursor_type
= NO_CURSOR
;
10846 /* Display or clear cursor of window W. If ON is zero, clear the
10847 cursor. If it is non-zero, display the cursor. If ON is nonzero,
10848 where to put the cursor is specified by HPOS, VPOS, X and Y. */
10851 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
10853 int on
, hpos
, vpos
, x
, y
;
10855 struct frame
*f
= XFRAME (w
->frame
);
10856 int new_cursor_type
;
10857 int new_cursor_width
;
10858 struct glyph_matrix
*current_glyphs
;
10859 struct glyph_row
*glyph_row
;
10860 struct glyph
*glyph
;
10862 /* This is pointless on invisible frames, and dangerous on garbaged
10863 windows and frames; in the latter case, the frame or window may
10864 be in the midst of changing its size, and x and y may be off the
10866 if (! FRAME_VISIBLE_P (f
)
10867 || FRAME_GARBAGED_P (f
)
10868 || vpos
>= w
->current_matrix
->nrows
10869 || hpos
>= w
->current_matrix
->matrix_w
)
10872 /* If cursor is off and we want it off, return quickly. */
10873 if (!on
&& !w
->phys_cursor_on_p
)
10876 current_glyphs
= w
->current_matrix
;
10877 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
10878 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
10880 /* If cursor row is not enabled, we don't really know where to
10881 display the cursor. */
10882 if (!glyph_row
->enabled_p
)
10884 w
->phys_cursor_on_p
= 0;
10888 xassert (interrupt_input_blocked
);
10890 /* Set new_cursor_type to the cursor we want to be displayed. In a
10891 mini-buffer window, we want the cursor only to appear if we are
10892 reading input from this window. For the selected window, we want
10893 the cursor type given by the frame parameter. If explicitly
10894 marked off, draw no cursor. In all other cases, we want a hollow
10896 new_cursor_width
= -1;
10897 if (cursor_in_echo_area
10898 && FRAME_HAS_MINIBUF_P (f
)
10899 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
10901 if (w
== XWINDOW (echo_area_window
))
10902 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
10904 new_cursor_type
= HOLLOW_BOX_CURSOR
;
10908 if (f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
10909 || w
!= XWINDOW (f
->selected_window
))
10911 extern int cursor_in_non_selected_windows
;
10913 if (MINI_WINDOW_P (w
)
10914 || !cursor_in_non_selected_windows
10915 || NILP (XBUFFER (w
->buffer
)->cursor_type
))
10916 new_cursor_type
= NO_CURSOR
;
10918 new_cursor_type
= HOLLOW_BOX_CURSOR
;
10920 else if (w
->cursor_off_p
)
10921 new_cursor_type
= NO_CURSOR
;
10924 struct buffer
*b
= XBUFFER (w
->buffer
);
10926 if (EQ (b
->cursor_type
, Qt
))
10927 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
10929 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
10930 &new_cursor_width
);
10934 /* If cursor is currently being shown and we don't want it to be or
10935 it is in the wrong place, or the cursor type is not what we want,
10937 if (w
->phys_cursor_on_p
10939 || w
->phys_cursor
.x
!= x
10940 || w
->phys_cursor
.y
!= y
10941 || new_cursor_type
!= w
->phys_cursor_type
))
10942 x_erase_phys_cursor (w
);
10944 /* If the cursor is now invisible and we want it to be visible,
10946 if (on
&& !w
->phys_cursor_on_p
)
10948 w
->phys_cursor_ascent
= glyph_row
->ascent
;
10949 w
->phys_cursor_height
= glyph_row
->height
;
10951 /* Set phys_cursor_.* before x_draw_.* is called because some
10952 of them may need the information. */
10953 w
->phys_cursor
.x
= x
;
10954 w
->phys_cursor
.y
= glyph_row
->y
;
10955 w
->phys_cursor
.hpos
= hpos
;
10956 w
->phys_cursor
.vpos
= vpos
;
10957 w
->phys_cursor_type
= new_cursor_type
;
10958 w
->phys_cursor_on_p
= 1;
10960 switch (new_cursor_type
)
10962 case HOLLOW_BOX_CURSOR
:
10963 x_draw_hollow_cursor (w
, glyph_row
);
10966 case FILLED_BOX_CURSOR
:
10967 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
10971 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
);
10982 if (w
== XWINDOW (f
->selected_window
))
10983 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
10984 xic_set_preeditarea (w
, x
, y
);
10989 if (updating_frame
!= f
)
10990 XFlush (FRAME_X_DISPLAY (f
));
10995 /* Display the cursor on window W, or clear it. X and Y are window
10996 relative pixel coordinates. HPOS and VPOS are glyph matrix
10997 positions. If W is not the selected window, display a hollow
10998 cursor. ON non-zero means display the cursor at X, Y which
10999 correspond to HPOS, VPOS, otherwise it is cleared. */
11002 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
11004 int on
, hpos
, vpos
, x
, y
;
11007 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
11012 /* Display the cursor on window W, or clear it, according to ON_P.
11013 Don't change the cursor's position. */
11016 x_update_cursor (f
, on_p
)
11019 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
11023 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
11024 in the window tree rooted at W. */
11027 x_update_cursor_in_window_tree (w
, on_p
)
11033 if (!NILP (w
->hchild
))
11034 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
11035 else if (!NILP (w
->vchild
))
11036 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
11038 x_update_window_cursor (w
, on_p
);
11040 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
11045 /* Switch the display of W's cursor on or off, according to the value
11049 x_update_window_cursor (w
, on
)
11053 /* Don't update cursor in windows whose frame is in the process
11054 of being deleted. */
11055 if (w
->current_matrix
)
11058 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
11059 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
11069 /* Refresh bitmap kitchen sink icon for frame F
11070 when we get an expose event for it. */
11076 /* Normally, the window manager handles this function. */
11079 /* Make the x-window of frame F use the gnu icon bitmap. */
11082 x_bitmap_icon (f
, file
)
11088 if (FRAME_X_WINDOW (f
) == 0)
11091 /* Free up our existing icon bitmap if any. */
11092 if (f
->output_data
.x
->icon_bitmap
> 0)
11093 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
11094 f
->output_data
.x
->icon_bitmap
= 0;
11096 if (STRINGP (file
))
11097 bitmap_id
= x_create_bitmap_from_file (f
, file
);
11100 /* Create the GNU bitmap if necessary. */
11101 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
11102 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
11103 = x_create_bitmap_from_data (f
, gnu_bits
,
11104 gnu_width
, gnu_height
);
11106 /* The first time we create the GNU bitmap,
11107 this increments the ref-count one extra time.
11108 As a result, the GNU bitmap is never freed.
11109 That way, we don't have to worry about allocating it again. */
11110 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
11112 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
11115 x_wm_set_icon_pixmap (f
, bitmap_id
);
11116 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
11122 /* Make the x-window of frame F use a rectangle with text.
11123 Use ICON_NAME as the text. */
11126 x_text_icon (f
, icon_name
)
11130 if (FRAME_X_WINDOW (f
) == 0)
11135 XTextProperty text
;
11136 text
.value
= (unsigned char *) icon_name
;
11137 text
.encoding
= XA_STRING
;
11139 text
.nitems
= strlen (icon_name
);
11140 #ifdef USE_X_TOOLKIT
11141 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
11143 #else /* not USE_X_TOOLKIT */
11144 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
11145 #endif /* not USE_X_TOOLKIT */
11147 #else /* not HAVE_X11R4 */
11148 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
11149 #endif /* not HAVE_X11R4 */
11151 if (f
->output_data
.x
->icon_bitmap
> 0)
11152 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
11153 f
->output_data
.x
->icon_bitmap
= 0;
11154 x_wm_set_icon_pixmap (f
, 0);
11159 #define X_ERROR_MESSAGE_SIZE 200
11161 /* If non-nil, this should be a string.
11162 It means catch X errors and store the error message in this string. */
11164 static Lisp_Object x_error_message_string
;
11166 /* An X error handler which stores the error message in
11167 x_error_message_string. This is called from x_error_handler if
11168 x_catch_errors is in effect. */
11171 x_error_catcher (display
, error
)
11173 XErrorEvent
*error
;
11175 XGetErrorText (display
, error
->error_code
,
11176 XSTRING (x_error_message_string
)->data
,
11177 X_ERROR_MESSAGE_SIZE
);
11180 /* Begin trapping X errors for display DPY. Actually we trap X errors
11181 for all displays, but DPY should be the display you are actually
11184 After calling this function, X protocol errors no longer cause
11185 Emacs to exit; instead, they are recorded in the string
11186 stored in x_error_message_string.
11188 Calling x_check_errors signals an Emacs error if an X error has
11189 occurred since the last call to x_catch_errors or x_check_errors.
11191 Calling x_uncatch_errors resumes the normal error handling. */
11193 void x_check_errors ();
11194 static Lisp_Object
x_catch_errors_unwind ();
11197 x_catch_errors (dpy
)
11200 int count
= specpdl_ptr
- specpdl
;
11202 /* Make sure any errors from previous requests have been dealt with. */
11203 XSync (dpy
, False
);
11205 record_unwind_protect (x_catch_errors_unwind
, x_error_message_string
);
11207 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
11208 XSTRING (x_error_message_string
)->data
[0] = 0;
11213 /* Unbind the binding that we made to check for X errors. */
11216 x_catch_errors_unwind (old_val
)
11217 Lisp_Object old_val
;
11219 x_error_message_string
= old_val
;
11223 /* If any X protocol errors have arrived since the last call to
11224 x_catch_errors or x_check_errors, signal an Emacs error using
11225 sprintf (a buffer, FORMAT, the x error message text) as the text. */
11228 x_check_errors (dpy
, format
)
11232 /* Make sure to catch any errors incurred so far. */
11233 XSync (dpy
, False
);
11235 if (XSTRING (x_error_message_string
)->data
[0])
11236 error (format
, XSTRING (x_error_message_string
)->data
);
11239 /* Nonzero if we had any X protocol errors
11240 since we did x_catch_errors on DPY. */
11243 x_had_errors_p (dpy
)
11246 /* Make sure to catch any errors incurred so far. */
11247 XSync (dpy
, False
);
11249 return XSTRING (x_error_message_string
)->data
[0] != 0;
11252 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
11255 x_clear_errors (dpy
)
11258 XSTRING (x_error_message_string
)->data
[0] = 0;
11261 /* Stop catching X protocol errors and let them make Emacs die.
11262 DPY should be the display that was passed to x_catch_errors.
11263 COUNT should be the value that was returned by
11264 the corresponding call to x_catch_errors. */
11267 x_uncatch_errors (dpy
, count
)
11271 unbind_to (count
, Qnil
);
11275 static unsigned int x_wire_count
;
11278 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
11283 /* Handle SIGPIPE, which can happen when the connection to a server
11284 simply goes away. SIGPIPE is handled by x_connection_signal.
11285 Don't need to do anything, because the write which caused the
11286 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
11287 which will do the appropriate cleanup for us. */
11290 x_connection_signal (signalnum
) /* If we don't have an argument, */
11291 int signalnum
; /* some compilers complain in signal calls. */
11294 /* USG systems forget handlers when they are used;
11295 must reestablish each time */
11296 signal (signalnum
, x_connection_signal
);
11301 /************************************************************************
11303 ************************************************************************/
11305 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
11306 the text of an error message that lead to the connection loss. */
11309 x_connection_closed (dpy
, error_message
)
11311 char *error_message
;
11313 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
11314 Lisp_Object frame
, tail
;
11318 msg
= (char *) alloca (strlen (error_message
) + 1);
11319 strcpy (msg
, error_message
);
11320 handling_signal
= 0;
11322 /* Prevent being called recursively because of an error condition
11323 below. Otherwise, we might end up with printing ``can't find per
11324 display information'' in the recursive call instead of printing
11325 the original message here. */
11326 count
= x_catch_errors (dpy
);
11328 /* We have to close the display to inform Xt that it doesn't
11329 exist anymore. If we don't, Xt will continue to wait for
11330 events from the display. As a consequence, a sequence of
11332 M-x make-frame-on-display RET :1 RET
11333 ...kill the new frame, so that we get an IO error...
11334 M-x make-frame-on-display RET :1 RET
11336 will indefinitely wait in Xt for events for display `:1', opened
11337 in the first class to make-frame-on-display.
11339 Closing the display is reported to lead to a bus error on
11340 OpenWindows in certain situations. I suspect that is a bug
11341 in OpenWindows. I don't know how to cicumvent it here. */
11343 #ifdef USE_X_TOOLKIT
11344 /* If DPYINFO is null, this means we didn't open the display
11345 in the first place, so don't try to close it. */
11347 XtCloseDisplay (dpy
);
11350 /* Indicate that this display is dead. */
11352 dpyinfo
->display
= 0;
11354 /* First delete frames whose mini-buffers are on frames
11355 that are on the dead display. */
11356 FOR_EACH_FRAME (tail
, frame
)
11358 Lisp_Object minibuf_frame
;
11360 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
11361 if (FRAME_X_P (XFRAME (frame
))
11362 && FRAME_X_P (XFRAME (minibuf_frame
))
11363 && ! EQ (frame
, minibuf_frame
)
11364 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
11365 Fdelete_frame (frame
, Qt
);
11368 /* Now delete all remaining frames on the dead display.
11369 We are now sure none of these is used as the mini-buffer
11370 for another frame that we need to delete. */
11371 FOR_EACH_FRAME (tail
, frame
)
11372 if (FRAME_X_P (XFRAME (frame
))
11373 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
11375 /* Set this to t so that Fdelete_frame won't get confused
11376 trying to find a replacement. */
11377 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
11378 Fdelete_frame (frame
, Qt
);
11382 x_delete_display (dpyinfo
);
11384 x_uncatch_errors (dpy
, count
);
11386 if (x_display_list
== 0)
11388 fprintf (stderr
, "%s\n", msg
);
11389 shut_down_emacs (0, 0, Qnil
);
11393 /* Ordinary stack unwind doesn't deal with these. */
11395 sigunblock (sigmask (SIGIO
));
11397 sigunblock (sigmask (SIGALRM
));
11398 TOTALLY_UNBLOCK_INPUT
;
11400 clear_waiting_for_input ();
11405 /* This is the usual handler for X protocol errors.
11406 It kills all frames on the display that we got the error for.
11407 If that was the only one, it prints an error message and kills Emacs. */
11410 x_error_quitter (display
, error
)
11412 XErrorEvent
*error
;
11414 char buf
[256], buf1
[356];
11416 /* Note that there is no real way portable across R3/R4 to get the
11417 original error handler. */
11419 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
11420 sprintf (buf1
, "X protocol error: %s on protocol request %d",
11421 buf
, error
->request_code
);
11422 x_connection_closed (display
, buf1
);
11426 /* This is the first-level handler for X protocol errors.
11427 It calls x_error_quitter or x_error_catcher. */
11430 x_error_handler (display
, error
)
11432 XErrorEvent
*error
;
11434 if (! NILP (x_error_message_string
))
11435 x_error_catcher (display
, error
);
11437 x_error_quitter (display
, error
);
11441 /* This is the handler for X IO errors, always.
11442 It kills all frames on the display that we lost touch with.
11443 If that was the only one, it prints an error message and kills Emacs. */
11446 x_io_error_quitter (display
)
11451 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
11452 x_connection_closed (display
, buf
);
11456 /* Changing the font of the frame. */
11458 /* Give frame F the font named FONTNAME as its default font, and
11459 return the full name of that font. FONTNAME may be a wildcard
11460 pattern; in that case, we choose some font that fits the pattern.
11461 The return value shows which font we chose. */
11464 x_new_font (f
, fontname
)
11466 register char *fontname
;
11468 struct font_info
*fontp
11469 = FS_LOAD_FONT (f
, 0, fontname
, -1);
11474 f
->output_data
.x
->font
= (XFontStruct
*) (fontp
->font
);
11475 f
->output_data
.x
->baseline_offset
= fontp
->baseline_offset
;
11476 f
->output_data
.x
->fontset
= -1;
11478 /* Compute the scroll bar width in character columns. */
11479 if (f
->scroll_bar_pixel_width
> 0)
11481 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
11482 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
11486 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
11487 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
11490 /* Now make the frame display the given font. */
11491 if (FRAME_X_WINDOW (f
) != 0)
11493 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
11494 f
->output_data
.x
->font
->fid
);
11495 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
11496 f
->output_data
.x
->font
->fid
);
11497 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
11498 f
->output_data
.x
->font
->fid
);
11500 frame_update_line_height (f
);
11502 /* Don't change the size of a tip frame; there's no point in
11503 doing it because it's done in Fx_show_tip, and it leads to
11504 problems because the tip frame has no widget. */
11505 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
11506 x_set_window_size (f
, 0, f
->width
, f
->height
);
11509 /* If we are setting a new frame's font for the first time,
11510 there are no faces yet, so this font's height is the line height. */
11511 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
11513 return build_string (fontp
->full_name
);
11516 /* Give frame F the fontset named FONTSETNAME as its default font, and
11517 return the full name of that fontset. FONTSETNAME may be a wildcard
11518 pattern; in that case, we choose some fontset that fits the pattern.
11519 The return value shows which fontset we chose. */
11522 x_new_fontset (f
, fontsetname
)
11526 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
11527 Lisp_Object result
;
11532 if (f
->output_data
.x
->fontset
== fontset
)
11533 /* This fontset is already set in frame F. There's nothing more
11535 return fontset_name (fontset
);
11537 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
11539 if (!STRINGP (result
))
11540 /* Can't load ASCII font. */
11543 /* Since x_new_font doesn't update any fontset information, do it now. */
11544 f
->output_data
.x
->fontset
= fontset
;
11548 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
11549 xic_set_xfontset (f
, XSTRING (fontset_ascii (fontset
))->data
);
11552 return build_string (fontsetname
);
11556 /***********************************************************************
11558 ***********************************************************************/
11564 /* XIM destroy callback function, which is called whenever the
11565 connection to input method XIM dies. CLIENT_DATA contains a
11566 pointer to the x_display_info structure corresponding to XIM. */
11569 xim_destroy_callback (xim
, client_data
, call_data
)
11571 XPointer client_data
;
11572 XPointer call_data
;
11574 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
11575 Lisp_Object frame
, tail
;
11579 /* No need to call XDestroyIC.. */
11580 FOR_EACH_FRAME (tail
, frame
)
11582 struct frame
*f
= XFRAME (frame
);
11583 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
11585 FRAME_XIC (f
) = NULL
;
11586 if (FRAME_XIC_FONTSET (f
))
11588 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
11589 FRAME_XIC_FONTSET (f
) = NULL
;
11594 /* No need to call XCloseIM. */
11595 dpyinfo
->xim
= NULL
;
11596 XFree (dpyinfo
->xim_styles
);
11600 #endif /* HAVE_X11R6 */
11602 /* Open the connection to the XIM server on display DPYINFO.
11603 RESOURCE_NAME is the resource name Emacs uses. */
11606 xim_open_dpy (dpyinfo
, resource_name
)
11607 struct x_display_info
*dpyinfo
;
11608 char *resource_name
;
11613 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
, EMACS_CLASS
);
11614 dpyinfo
->xim
= xim
;
11619 XIMCallback destroy
;
11622 /* Get supported styles and XIM values. */
11623 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
11626 destroy
.callback
= xim_destroy_callback
;
11627 destroy
.client_data
= (XPointer
)dpyinfo
;
11628 /* This isn't prptotyped in OSF 5.0. */
11629 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
11633 #else /* not USE_XIM */
11634 dpyinfo
->xim
= NULL
;
11635 #endif /* not USE_XIM */
11639 #ifdef HAVE_X11R6_XIM
11643 struct x_display_info
*dpyinfo
;
11644 char *resource_name
;
11647 /* XIM instantiate callback function, which is called whenever an XIM
11648 server is available. DISPLAY is teh display of the XIM.
11649 CLIENT_DATA contains a pointer to an xim_inst_t structure created
11650 when the callback was registered. */
11653 xim_instantiate_callback (display
, client_data
, call_data
)
11655 XPointer client_data
;
11656 XPointer call_data
;
11658 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
11659 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
11661 /* We don't support multiple XIM connections. */
11665 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
11667 /* Create XIC for the existing frames on the same display, as long
11668 as they have no XIC. */
11669 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
11671 Lisp_Object tail
, frame
;
11674 FOR_EACH_FRAME (tail
, frame
)
11676 struct frame
*f
= XFRAME (frame
);
11678 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
11679 if (FRAME_XIC (f
) == NULL
)
11681 create_frame_xic (f
);
11682 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
11683 xic_set_statusarea (f
);
11684 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
11686 struct window
*w
= XWINDOW (f
->selected_window
);
11687 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
11696 #endif /* HAVE_X11R6_XIM */
11699 /* Open a connection to the XIM server on display DPYINFO.
11700 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
11701 connection only at the first time. On X11R6, open the connection
11702 in the XIM instantiate callback function. */
11705 xim_initialize (dpyinfo
, resource_name
)
11706 struct x_display_info
*dpyinfo
;
11707 char *resource_name
;
11710 #ifdef HAVE_X11R6_XIM
11711 struct xim_inst_t
*xim_inst
;
11714 dpyinfo
->xim
= NULL
;
11715 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
11716 xim_inst
->dpyinfo
= dpyinfo
;
11717 len
= strlen (resource_name
);
11718 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
11719 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
11720 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
11721 resource_name
, EMACS_CLASS
,
11722 xim_instantiate_callback
,
11723 /* Fixme: This is XPointer in
11724 XFree86 but (XPointer *) on
11725 Tru64, at least. */
11726 (XPointer
) xim_inst
);
11727 #else /* not HAVE_X11R6_XIM */
11728 dpyinfo
->xim
= NULL
;
11729 xim_open_dpy (dpyinfo
, resource_name
);
11730 #endif /* not HAVE_X11R6_XIM */
11732 #else /* not USE_XIM */
11733 dpyinfo
->xim
= NULL
;
11734 #endif /* not USE_XIM */
11738 /* Close the connection to the XIM server on display DPYINFO. */
11741 xim_close_dpy (dpyinfo
)
11742 struct x_display_info
*dpyinfo
;
11745 #ifdef HAVE_X11R6_XIM
11746 if (dpyinfo
->display
)
11747 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
11749 xim_instantiate_callback
, NULL
);
11750 #endif /* not HAVE_X11R6_XIM */
11751 if (dpyinfo
->display
)
11752 XCloseIM (dpyinfo
->xim
);
11753 dpyinfo
->xim
= NULL
;
11754 XFree (dpyinfo
->xim_styles
);
11755 #endif /* USE_XIM */
11758 #endif /* not HAVE_X11R6_XIM */
11762 /* Calculate the absolute position in frame F
11763 from its current recorded position values and gravity. */
11766 x_calc_absolute_position (f
)
11770 int win_x
= 0, win_y
= 0;
11771 int flags
= f
->output_data
.x
->size_hint_flags
;
11774 /* We have nothing to do if the current position
11775 is already for the top-left corner. */
11776 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
11779 #ifdef USE_X_TOOLKIT
11780 this_window
= XtWindow (f
->output_data
.x
->widget
);
11782 this_window
= FRAME_X_WINDOW (f
);
11785 /* Find the position of the outside upper-left corner of
11786 the inner window, with respect to the outer window.
11787 But do this only if we will need the results. */
11788 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
11793 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
11796 x_clear_errors (FRAME_X_DISPLAY (f
));
11797 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
11799 /* From-window, to-window. */
11801 f
->output_data
.x
->parent_desc
,
11803 /* From-position, to-position. */
11804 0, 0, &win_x
, &win_y
,
11806 /* Child of win. */
11808 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
11810 Window newroot
, newparent
= 0xdeadbeef;
11811 Window
*newchildren
;
11812 unsigned int nchildren
;
11814 if (! XQueryTree (FRAME_X_DISPLAY (f
), this_window
, &newroot
,
11815 &newparent
, &newchildren
, &nchildren
))
11818 XFree ((char *) newchildren
);
11820 f
->output_data
.x
->parent_desc
= newparent
;
11826 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
11830 /* Treat negative positions as relative to the leftmost bottommost
11831 position that fits on the screen. */
11832 if (flags
& XNegative
)
11833 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
11834 - 2 * f
->output_data
.x
->border_width
- win_x
11836 + f
->output_data
.x
->left_pos
);
11839 int height
= PIXEL_HEIGHT (f
);
11841 #if defined USE_X_TOOLKIT && defined USE_MOTIF
11842 /* Something is fishy here. When using Motif, starting Emacs with
11843 `-g -0-0', the frame appears too low by a few pixels.
11845 This seems to be so because initially, while Emacs is starting,
11846 the column widget's height and the frame's pixel height are
11847 different. The column widget's height is the right one. In
11848 later invocations, when Emacs is up, the frame's pixel height
11851 It's not obvious where the initial small difference comes from.
11852 2000-12-01, gerd. */
11854 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
11857 if (flags
& YNegative
)
11858 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
11859 - 2 * f
->output_data
.x
->border_width
11862 + f
->output_data
.x
->top_pos
);
11865 /* The left_pos and top_pos
11866 are now relative to the top and left screen edges,
11867 so the flags should correspond. */
11868 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
11871 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
11872 to really change the position, and 0 when calling from
11873 x_make_frame_visible (in that case, XOFF and YOFF are the current
11874 position values). It is -1 when calling from x_set_frame_parameters,
11875 which means, do adjust for borders but don't change the gravity. */
11878 x_set_offset (f
, xoff
, yoff
, change_gravity
)
11880 register int xoff
, yoff
;
11881 int change_gravity
;
11883 int modified_top
, modified_left
;
11885 if (change_gravity
> 0)
11887 f
->output_data
.x
->top_pos
= yoff
;
11888 f
->output_data
.x
->left_pos
= xoff
;
11889 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
11891 f
->output_data
.x
->size_hint_flags
|= XNegative
;
11893 f
->output_data
.x
->size_hint_flags
|= YNegative
;
11894 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11896 x_calc_absolute_position (f
);
11899 x_wm_set_size_hint (f
, (long) 0, 0);
11901 modified_left
= f
->output_data
.x
->left_pos
;
11902 modified_top
= f
->output_data
.x
->top_pos
;
11903 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
11904 this seems to be unnecessary and incorrect. rms, 4/17/97. */
11905 /* It is a mystery why we need to add the border_width here
11906 when the frame is already visible, but experiment says we do. */
11907 if (change_gravity
!= 0)
11909 modified_left
+= f
->output_data
.x
->border_width
;
11910 modified_top
+= f
->output_data
.x
->border_width
;
11914 #ifdef USE_X_TOOLKIT
11915 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
11916 modified_left
, modified_top
);
11917 #else /* not USE_X_TOOLKIT */
11918 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11919 modified_left
, modified_top
);
11920 #endif /* not USE_X_TOOLKIT */
11925 /* Change the size of frame F's X window to COLS/ROWS in the case F
11926 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
11927 top-left-corner window gravity for this size change and subsequent
11928 size changes. Otherwise we leave the window gravity unchanged. */
11931 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
11933 int change_gravity
;
11936 int pixelwidth
, pixelheight
;
11938 check_frame_size (f
, &rows
, &cols
);
11939 f
->output_data
.x
->vertical_scroll_bar_extra
11940 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
11942 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
11943 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
11944 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
11945 f
->output_data
.x
->flags_areas_extra
11946 = FRAME_FLAGS_AREA_WIDTH (f
);
11947 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
11948 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
11950 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11951 x_wm_set_size_hint (f
, (long) 0, 0);
11953 XSync (FRAME_X_DISPLAY (f
), False
);
11954 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11955 pixelwidth
, pixelheight
);
11957 /* Now, strictly speaking, we can't be sure that this is accurate,
11958 but the window manager will get around to dealing with the size
11959 change request eventually, and we'll hear how it went when the
11960 ConfigureNotify event gets here.
11962 We could just not bother storing any of this information here,
11963 and let the ConfigureNotify event set everything up, but that
11964 might be kind of confusing to the Lisp code, since size changes
11965 wouldn't be reported in the frame parameters until some random
11966 point in the future when the ConfigureNotify event arrives.
11968 We pass 1 for DELAY since we can't run Lisp code inside of
11970 change_frame_size (f
, rows
, cols
, 0, 1, 0);
11971 PIXEL_WIDTH (f
) = pixelwidth
;
11972 PIXEL_HEIGHT (f
) = pixelheight
;
11974 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
11975 receive in the ConfigureNotify event; if we get what we asked
11976 for, then the event won't cause the screen to become garbaged, so
11977 we have to make sure to do it here. */
11978 SET_FRAME_GARBAGED (f
);
11980 XFlush (FRAME_X_DISPLAY (f
));
11984 /* Call this to change the size of frame F's x-window.
11985 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
11986 for this size change and subsequent size changes.
11987 Otherwise we leave the window gravity unchanged. */
11990 x_set_window_size (f
, change_gravity
, cols
, rows
)
11992 int change_gravity
;
11997 #ifdef USE_X_TOOLKIT
11999 if (f
->output_data
.x
->widget
!= None
)
12001 /* The x and y position of the widget is clobbered by the
12002 call to XtSetValues within EmacsFrameSetCharSize.
12003 This is a real kludge, but I don't understand Xt so I can't
12004 figure out a correct fix. Can anyone else tell me? -- rms. */
12005 int xpos
= f
->output_data
.x
->widget
->core
.x
;
12006 int ypos
= f
->output_data
.x
->widget
->core
.y
;
12007 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
12008 f
->output_data
.x
->widget
->core
.x
= xpos
;
12009 f
->output_data
.x
->widget
->core
.y
= ypos
;
12012 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
12014 #else /* not USE_X_TOOLKIT */
12016 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
12018 #endif /* not USE_X_TOOLKIT */
12020 /* If cursor was outside the new size, mark it as off. */
12021 mark_window_cursors_off (XWINDOW (f
->root_window
));
12023 /* Clear out any recollection of where the mouse highlighting was,
12024 since it might be in a place that's outside the new frame size.
12025 Actually checking whether it is outside is a pain in the neck,
12026 so don't try--just let the highlighting be done afresh with new size. */
12027 cancel_mouse_face (f
);
12032 /* Mouse warping. */
12035 x_set_mouse_position (f
, x
, y
)
12041 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
12042 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
12044 if (pix_x
< 0) pix_x
= 0;
12045 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
12047 if (pix_y
< 0) pix_y
= 0;
12048 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
12052 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
12053 0, 0, 0, 0, pix_x
, pix_y
);
12057 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
12060 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
12066 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
12067 0, 0, 0, 0, pix_x
, pix_y
);
12071 /* focus shifting, raising and lowering. */
12074 x_focus_on_frame (f
)
12077 #if 0 /* This proves to be unpleasant. */
12081 /* I don't think that the ICCCM allows programs to do things like this
12082 without the interaction of the window manager. Whatever you end up
12083 doing with this code, do it to x_unfocus_frame too. */
12084 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
12085 RevertToPointerRoot
, CurrentTime
);
12090 x_unfocus_frame (f
)
12094 /* Look at the remarks in x_focus_on_frame. */
12095 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
12096 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
12097 RevertToPointerRoot
, CurrentTime
);
12101 /* Raise frame F. */
12107 if (f
->async_visible
)
12110 #ifdef USE_X_TOOLKIT
12111 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
12112 #else /* not USE_X_TOOLKIT */
12113 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12114 #endif /* not USE_X_TOOLKIT */
12115 XFlush (FRAME_X_DISPLAY (f
));
12120 /* Lower frame F. */
12126 if (f
->async_visible
)
12129 #ifdef USE_X_TOOLKIT
12130 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
12131 #else /* not USE_X_TOOLKIT */
12132 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12133 #endif /* not USE_X_TOOLKIT */
12134 XFlush (FRAME_X_DISPLAY (f
));
12140 XTframe_raise_lower (f
, raise_flag
)
12150 /* Change of visibility. */
12152 /* This tries to wait until the frame is really visible.
12153 However, if the window manager asks the user where to position
12154 the frame, this will return before the user finishes doing that.
12155 The frame will not actually be visible at that time,
12156 but it will become visible later when the window manager
12157 finishes with it. */
12160 x_make_frame_visible (f
)
12164 int original_top
, original_left
;
12165 int retry_count
= 2;
12171 type
= x_icon_type (f
);
12173 x_bitmap_icon (f
, type
);
12175 if (! FRAME_VISIBLE_P (f
))
12177 /* We test FRAME_GARBAGED_P here to make sure we don't
12178 call x_set_offset a second time
12179 if we get to x_make_frame_visible a second time
12180 before the window gets really visible. */
12181 if (! FRAME_ICONIFIED_P (f
)
12182 && ! f
->output_data
.x
->asked_for_visible
)
12183 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
12185 f
->output_data
.x
->asked_for_visible
= 1;
12187 if (! EQ (Vx_no_window_manager
, Qt
))
12188 x_wm_set_window_state (f
, NormalState
);
12189 #ifdef USE_X_TOOLKIT
12190 /* This was XtPopup, but that did nothing for an iconified frame. */
12191 XtMapWidget (f
->output_data
.x
->widget
);
12192 #else /* not USE_X_TOOLKIT */
12193 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12194 #endif /* not USE_X_TOOLKIT */
12195 #if 0 /* This seems to bring back scroll bars in the wrong places
12196 if the window configuration has changed. They seem
12197 to come back ok without this. */
12198 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
12199 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12203 XFlush (FRAME_X_DISPLAY (f
));
12205 /* Synchronize to ensure Emacs knows the frame is visible
12206 before we do anything else. We do this loop with input not blocked
12207 so that incoming events are handled. */
12211 /* This must be before UNBLOCK_INPUT
12212 since events that arrive in response to the actions above
12213 will set it when they are handled. */
12214 int previously_visible
= f
->output_data
.x
->has_been_visible
;
12216 original_left
= f
->output_data
.x
->left_pos
;
12217 original_top
= f
->output_data
.x
->top_pos
;
12219 /* This must come after we set COUNT. */
12222 /* We unblock here so that arriving X events are processed. */
12224 /* Now move the window back to where it was "supposed to be".
12225 But don't do it if the gravity is negative.
12226 When the gravity is negative, this uses a position
12227 that is 3 pixels too low. Perhaps that's really the border width.
12229 Don't do this if the window has never been visible before,
12230 because the window manager may choose the position
12231 and we don't want to override it. */
12233 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
12234 && f
->output_data
.x
->win_gravity
== NorthWestGravity
12235 && previously_visible
)
12239 unsigned int width
, height
, border
, depth
;
12243 /* On some window managers (such as FVWM) moving an existing
12244 window, even to the same place, causes the window manager
12245 to introduce an offset. This can cause the window to move
12246 to an unexpected location. Check the geometry (a little
12247 slow here) and then verify that the window is in the right
12248 place. If the window is not in the right place, move it
12249 there, and take the potential window manager hit. */
12250 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
12251 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
12253 if (original_left
!= x
|| original_top
!= y
)
12254 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
12255 original_left
, original_top
);
12260 XSETFRAME (frame
, f
);
12262 /* Wait until the frame is visible. Process X events until a
12263 MapNotify event has been seen, or until we think we won't get a
12264 MapNotify at all.. */
12265 for (count
= input_signal_count
+ 10;
12266 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
12268 /* Force processing of queued events. */
12271 /* Machines that do polling rather than SIGIO have been
12272 observed to go into a busy-wait here. So we'll fake an
12273 alarm signal to let the handler know that there's something
12274 to be read. We used to raise a real alarm, but it seems
12275 that the handler isn't always enabled here. This is
12277 if (input_polling_used ())
12279 /* It could be confusing if a real alarm arrives while
12280 processing the fake one. Turn it off and let the
12281 handler reset it. */
12282 extern void poll_for_input_1
P_ ((void));
12283 int old_poll_suppress_count
= poll_suppress_count
;
12284 poll_suppress_count
= 1;
12285 poll_for_input_1 ();
12286 poll_suppress_count
= old_poll_suppress_count
;
12289 /* See if a MapNotify event has been processed. */
12290 FRAME_SAMPLE_VISIBILITY (f
);
12295 (let ((f (selected-frame)))
12299 the frame is not raised with various window managers on
12300 FreeBSD, Linux and Solaris. It turns out that, for some
12301 unknown reason, the call to XtMapWidget is completely ignored.
12302 Mapping the widget a second time works. */
12304 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
12309 /* Change from mapped state to withdrawn state. */
12311 /* Make the frame visible (mapped and not iconified). */
12314 x_make_frame_invisible (f
)
12319 #ifdef USE_X_TOOLKIT
12320 /* Use the frame's outermost window, not the one we normally draw on. */
12321 window
= XtWindow (f
->output_data
.x
->widget
);
12322 #else /* not USE_X_TOOLKIT */
12323 window
= FRAME_X_WINDOW (f
);
12324 #endif /* not USE_X_TOOLKIT */
12326 /* Don't keep the highlight on an invisible frame. */
12327 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
12328 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
12330 #if 0/* This might add unreliability; I don't trust it -- rms. */
12331 if (! f
->async_visible
&& ! f
->async_iconified
)
12337 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
12338 that the current position of the window is user-specified, rather than
12339 program-specified, so that when the window is mapped again, it will be
12340 placed at the same location, without forcing the user to position it
12341 by hand again (they have already done that once for this window.) */
12342 x_wm_set_size_hint (f
, (long) 0, 1);
12346 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
12347 DefaultScreen (FRAME_X_DISPLAY (f
))))
12349 UNBLOCK_INPUT_RESIGNAL
;
12350 error ("Can't notify window manager of window withdrawal");
12352 #else /* ! defined (HAVE_X11R4) */
12354 /* Tell the window manager what we're going to do. */
12355 if (! EQ (Vx_no_window_manager
, Qt
))
12359 unmap
.xunmap
.type
= UnmapNotify
;
12360 unmap
.xunmap
.window
= window
;
12361 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
12362 unmap
.xunmap
.from_configure
= False
;
12363 if (! XSendEvent (FRAME_X_DISPLAY (f
),
12364 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
12366 SubstructureRedirectMaskSubstructureNotifyMask
,
12369 UNBLOCK_INPUT_RESIGNAL
;
12370 error ("Can't notify window manager of withdrawal");
12374 /* Unmap the window ourselves. Cheeky! */
12375 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
12376 #endif /* ! defined (HAVE_X11R4) */
12378 /* We can't distinguish this from iconification
12379 just by the event that we get from the server.
12380 So we can't win using the usual strategy of letting
12381 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
12382 and synchronize with the server to make sure we agree. */
12384 FRAME_ICONIFIED_P (f
) = 0;
12385 f
->async_visible
= 0;
12386 f
->async_iconified
= 0;
12393 /* Change window state from mapped to iconified. */
12396 x_iconify_frame (f
)
12402 /* Don't keep the highlight on an invisible frame. */
12403 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
12404 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
12406 if (f
->async_iconified
)
12411 FRAME_SAMPLE_VISIBILITY (f
);
12413 type
= x_icon_type (f
);
12415 x_bitmap_icon (f
, type
);
12417 #ifdef USE_X_TOOLKIT
12419 if (! FRAME_VISIBLE_P (f
))
12421 if (! EQ (Vx_no_window_manager
, Qt
))
12422 x_wm_set_window_state (f
, IconicState
);
12423 /* This was XtPopup, but that did nothing for an iconified frame. */
12424 XtMapWidget (f
->output_data
.x
->widget
);
12425 /* The server won't give us any event to indicate
12426 that an invisible frame was changed to an icon,
12427 so we have to record it here. */
12430 f
->async_iconified
= 1;
12431 f
->async_visible
= 0;
12436 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
12437 XtWindow (f
->output_data
.x
->widget
),
12438 DefaultScreen (FRAME_X_DISPLAY (f
)));
12442 error ("Can't notify window manager of iconification");
12444 f
->async_iconified
= 1;
12445 f
->async_visible
= 0;
12449 XFlush (FRAME_X_DISPLAY (f
));
12451 #else /* not USE_X_TOOLKIT */
12453 /* Make sure the X server knows where the window should be positioned,
12454 in case the user deiconifies with the window manager. */
12455 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
12456 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
12458 /* Since we don't know which revision of X we're running, we'll use both
12459 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
12461 /* X11R4: send a ClientMessage to the window manager using the
12462 WM_CHANGE_STATE type. */
12466 message
.xclient
.window
= FRAME_X_WINDOW (f
);
12467 message
.xclient
.type
= ClientMessage
;
12468 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
12469 message
.xclient
.format
= 32;
12470 message
.xclient
.data
.l
[0] = IconicState
;
12472 if (! XSendEvent (FRAME_X_DISPLAY (f
),
12473 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
12475 SubstructureRedirectMask
| SubstructureNotifyMask
,
12478 UNBLOCK_INPUT_RESIGNAL
;
12479 error ("Can't notify window manager of iconification");
12483 /* X11R3: set the initial_state field of the window manager hints to
12485 x_wm_set_window_state (f
, IconicState
);
12487 if (!FRAME_VISIBLE_P (f
))
12489 /* If the frame was withdrawn, before, we must map it. */
12490 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12493 f
->async_iconified
= 1;
12494 f
->async_visible
= 0;
12496 XFlush (FRAME_X_DISPLAY (f
));
12498 #endif /* not USE_X_TOOLKIT */
12502 /* Free X resources of frame F. */
12505 x_free_frame_resources (f
)
12508 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12512 /* If a display connection is dead, don't try sending more
12513 commands to the X server. */
12514 if (dpyinfo
->display
)
12516 if (f
->output_data
.x
->icon_desc
)
12517 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
12521 free_frame_xic (f
);
12524 if (FRAME_X_WINDOW (f
))
12525 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
12527 #ifdef USE_X_TOOLKIT
12528 if (f
->output_data
.x
->widget
)
12529 XtDestroyWidget (f
->output_data
.x
->widget
);
12530 free_frame_menubar (f
);
12531 #endif /* USE_X_TOOLKIT */
12533 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
12534 unload_color (f
, f
->output_data
.x
->background_pixel
);
12535 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
12536 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
12537 unload_color (f
, f
->output_data
.x
->border_pixel
);
12538 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
12540 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
12541 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
12542 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
12543 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
12544 if (f
->output_data
.x
->white_relief
.allocated_p
)
12545 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
12546 if (f
->output_data
.x
->black_relief
.allocated_p
)
12547 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
12549 if (FRAME_FACE_CACHE (f
))
12550 free_frame_faces (f
);
12553 XFlush (FRAME_X_DISPLAY (f
));
12556 if (f
->output_data
.x
->saved_menu_event
)
12557 xfree (f
->output_data
.x
->saved_menu_event
);
12559 xfree (f
->output_data
.x
);
12560 f
->output_data
.x
= NULL
;
12562 if (f
== dpyinfo
->x_focus_frame
)
12563 dpyinfo
->x_focus_frame
= 0;
12564 if (f
== dpyinfo
->x_focus_event_frame
)
12565 dpyinfo
->x_focus_event_frame
= 0;
12566 if (f
== dpyinfo
->x_highlight_frame
)
12567 dpyinfo
->x_highlight_frame
= 0;
12569 if (f
== dpyinfo
->mouse_face_mouse_frame
)
12571 dpyinfo
->mouse_face_beg_row
12572 = dpyinfo
->mouse_face_beg_col
= -1;
12573 dpyinfo
->mouse_face_end_row
12574 = dpyinfo
->mouse_face_end_col
= -1;
12575 dpyinfo
->mouse_face_window
= Qnil
;
12576 dpyinfo
->mouse_face_deferred_gc
= 0;
12577 dpyinfo
->mouse_face_mouse_frame
= 0;
12584 /* Destroy the X window of frame F. */
12587 x_destroy_window (f
)
12590 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12592 /* If a display connection is dead, don't try sending more
12593 commands to the X server. */
12594 if (dpyinfo
->display
!= 0)
12595 x_free_frame_resources (f
);
12597 dpyinfo
->reference_count
--;
12601 /* Setting window manager hints. */
12603 /* Set the normal size hints for the window manager, for frame F.
12604 FLAGS is the flags word to use--or 0 meaning preserve the flags
12605 that the window now has.
12606 If USER_POSITION is nonzero, we set the USPosition
12607 flag (this is useful when FLAGS is 0). */
12610 x_wm_set_size_hint (f
, flags
, user_position
)
12615 XSizeHints size_hints
;
12617 #ifdef USE_X_TOOLKIT
12620 Dimension widget_width
, widget_height
;
12621 Window window
= XtWindow (f
->output_data
.x
->widget
);
12622 #else /* not USE_X_TOOLKIT */
12623 Window window
= FRAME_X_WINDOW (f
);
12624 #endif /* not USE_X_TOOLKIT */
12626 /* Setting PMaxSize caused various problems. */
12627 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
12629 size_hints
.x
= f
->output_data
.x
->left_pos
;
12630 size_hints
.y
= f
->output_data
.x
->top_pos
;
12632 #ifdef USE_X_TOOLKIT
12633 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
12634 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
12635 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
12636 size_hints
.height
= widget_height
;
12637 size_hints
.width
= widget_width
;
12638 #else /* not USE_X_TOOLKIT */
12639 size_hints
.height
= PIXEL_HEIGHT (f
);
12640 size_hints
.width
= PIXEL_WIDTH (f
);
12641 #endif /* not USE_X_TOOLKIT */
12643 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
12644 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
12645 size_hints
.max_width
12646 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
12647 size_hints
.max_height
12648 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
12650 /* Calculate the base and minimum sizes.
12652 (When we use the X toolkit, we don't do it here.
12653 Instead we copy the values that the widgets are using, below.) */
12654 #ifndef USE_X_TOOLKIT
12656 int base_width
, base_height
;
12657 int min_rows
= 0, min_cols
= 0;
12659 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
12660 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
12662 check_frame_size (f
, &min_rows
, &min_cols
);
12664 /* The window manager uses the base width hints to calculate the
12665 current number of rows and columns in the frame while
12666 resizing; min_width and min_height aren't useful for this
12667 purpose, since they might not give the dimensions for a
12668 zero-row, zero-column frame.
12670 We use the base_width and base_height members if we have
12671 them; otherwise, we set the min_width and min_height members
12672 to the size for a zero x zero frame. */
12675 size_hints
.flags
|= PBaseSize
;
12676 size_hints
.base_width
= base_width
;
12677 size_hints
.base_height
= base_height
;
12678 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
12679 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
12681 size_hints
.min_width
= base_width
;
12682 size_hints
.min_height
= base_height
;
12686 /* If we don't need the old flags, we don't need the old hint at all. */
12689 size_hints
.flags
|= flags
;
12692 #endif /* not USE_X_TOOLKIT */
12695 XSizeHints hints
; /* Sometimes I hate X Windows... */
12696 long supplied_return
;
12700 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
12703 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
12706 #ifdef USE_X_TOOLKIT
12707 size_hints
.base_height
= hints
.base_height
;
12708 size_hints
.base_width
= hints
.base_width
;
12709 size_hints
.min_height
= hints
.min_height
;
12710 size_hints
.min_width
= hints
.min_width
;
12714 size_hints
.flags
|= flags
;
12719 if (hints
.flags
& PSize
)
12720 size_hints
.flags
|= PSize
;
12721 if (hints
.flags
& PPosition
)
12722 size_hints
.flags
|= PPosition
;
12723 if (hints
.flags
& USPosition
)
12724 size_hints
.flags
|= USPosition
;
12725 if (hints
.flags
& USSize
)
12726 size_hints
.flags
|= USSize
;
12730 #ifndef USE_X_TOOLKIT
12735 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
12736 size_hints
.flags
|= PWinGravity
;
12740 size_hints
.flags
&= ~ PPosition
;
12741 size_hints
.flags
|= USPosition
;
12743 #endif /* PWinGravity */
12746 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
12748 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
12752 /* Used for IconicState or NormalState */
12755 x_wm_set_window_state (f
, state
)
12759 #ifdef USE_X_TOOLKIT
12762 XtSetArg (al
[0], XtNinitialState
, state
);
12763 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
12764 #else /* not USE_X_TOOLKIT */
12765 Window window
= FRAME_X_WINDOW (f
);
12767 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
12768 f
->output_data
.x
->wm_hints
.initial_state
= state
;
12770 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12771 #endif /* not USE_X_TOOLKIT */
12775 x_wm_set_icon_pixmap (f
, pixmap_id
)
12779 Pixmap icon_pixmap
;
12781 #ifndef USE_X_TOOLKIT
12782 Window window
= FRAME_X_WINDOW (f
);
12787 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
12788 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
12792 /* It seems there is no way to turn off use of an icon pixmap.
12793 The following line does it, only if no icon has yet been created,
12794 for some window managers. But with mwm it crashes.
12795 Some people say it should clear the IconPixmapHint bit in this case,
12796 but that doesn't work, and the X consortium said it isn't the
12797 right thing at all. Since there is no way to win,
12798 best to explicitly give up. */
12800 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
12806 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
12810 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
12811 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
12814 #else /* not USE_X_TOOLKIT */
12816 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
12817 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12819 #endif /* not USE_X_TOOLKIT */
12823 x_wm_set_icon_position (f
, icon_x
, icon_y
)
12825 int icon_x
, icon_y
;
12827 #ifdef USE_X_TOOLKIT
12828 Window window
= XtWindow (f
->output_data
.x
->widget
);
12830 Window window
= FRAME_X_WINDOW (f
);
12833 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
12834 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
12835 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
12837 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12841 /***********************************************************************
12843 ***********************************************************************/
12845 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
12848 x_get_font_info (f
, font_idx
)
12852 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
12856 /* Return a list of names of available fonts matching PATTERN on frame F.
12858 If SIZE is > 0, it is the size (maximum bounds width) of fonts
12861 SIZE < 0 means include scalable fonts.
12863 Frame F null means we have not yet created any frame on X, and
12864 consult the first display in x_display_list. MAXNAMES sets a limit
12865 on how many fonts to match. */
12868 x_list_fonts (f
, pattern
, size
, maxnames
)
12870 Lisp_Object pattern
;
12874 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
12875 Lisp_Object tem
, second_best
;
12876 struct x_display_info
*dpyinfo
12877 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
12878 Display
*dpy
= dpyinfo
->display
;
12879 int try_XLoadQueryFont
= 0;
12881 int allow_scalable_fonts_p
= 0;
12885 allow_scalable_fonts_p
= 1;
12889 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
12890 if (NILP (patterns
))
12891 patterns
= Fcons (pattern
, Qnil
);
12893 if (maxnames
== 1 && !size
)
12894 /* We can return any single font matching PATTERN. */
12895 try_XLoadQueryFont
= 1;
12897 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
12900 char **names
= NULL
;
12902 pattern
= XCAR (patterns
);
12903 /* See if we cached the result for this particular query.
12904 The cache is an alist of the form:
12905 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
12906 tem
= XCDR (dpyinfo
->name_list_element
);
12907 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
12908 allow_scalable_fonts_p
? Qt
: Qnil
);
12909 list
= Fassoc (key
, tem
);
12912 list
= Fcdr_safe (list
);
12913 /* We have a cashed list. Don't have to get the list again. */
12917 /* At first, put PATTERN in the cache. */
12920 count
= x_catch_errors (dpy
);
12922 if (try_XLoadQueryFont
)
12925 unsigned long value
;
12927 font
= XLoadQueryFont (dpy
, XSTRING (pattern
)->data
);
12928 if (x_had_errors_p (dpy
))
12930 /* This error is perhaps due to insufficient memory on X
12931 server. Let's just ignore it. */
12933 x_clear_errors (dpy
);
12937 && XGetFontProperty (font
, XA_FONT
, &value
))
12939 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
12940 int len
= strlen (name
);
12943 /* If DXPC (a Differential X Protocol Compressor)
12944 Ver.3.7 is running, XGetAtomName will return null
12945 string. We must avoid such a name. */
12947 try_XLoadQueryFont
= 0;
12951 names
= (char **) alloca (sizeof (char *));
12952 /* Some systems only allow alloca assigned to a
12954 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
12955 bcopy (name
, names
[0], len
+ 1);
12960 try_XLoadQueryFont
= 0;
12963 XFreeFont (dpy
, font
);
12966 if (!try_XLoadQueryFont
)
12968 /* We try at least 10 fonts because XListFonts will return
12969 auto-scaled fonts at the head. */
12970 names
= XListFonts (dpy
, XSTRING (pattern
)->data
, max (maxnames
, 10),
12972 if (x_had_errors_p (dpy
))
12974 /* This error is perhaps due to insufficient memory on X
12975 server. Let's just ignore it. */
12977 x_clear_errors (dpy
);
12981 x_uncatch_errors (dpy
, count
);
12988 /* Make a list of all the fonts we got back.
12989 Store that in the font cache for the display. */
12990 for (i
= 0; i
< num_fonts
; i
++)
12993 char *p
= names
[i
];
12994 int average_width
= -1, dashes
= 0;
12996 /* Count the number of dashes in NAMES[I]. If there are
12997 14 dashes, and the field value following 12th dash
12998 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
12999 is usually too ugly to be used for editing. Let's
13005 if (dashes
== 7) /* PIXEL_SIZE field */
13007 else if (dashes
== 12) /* AVERAGE_WIDTH field */
13008 average_width
= atoi (p
);
13011 if (allow_scalable_fonts_p
13012 || dashes
< 14 || average_width
!= 0)
13014 tem
= build_string (names
[i
]);
13015 if (NILP (Fassoc (tem
, list
)))
13017 if (STRINGP (Vx_pixel_size_width_font_regexp
)
13018 && ((fast_c_string_match_ignore_case
13019 (Vx_pixel_size_width_font_regexp
, names
[i
]))
13021 /* We can set the value of PIXEL_SIZE to the
13022 width of this font. */
13023 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
13025 /* For the moment, width is not known. */
13026 list
= Fcons (Fcons (tem
, Qnil
), list
);
13030 if (!try_XLoadQueryFont
)
13031 XFreeFontNames (names
);
13034 /* Now store the result in the cache. */
13035 XCDR (dpyinfo
->name_list_element
)
13036 = Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
));
13039 if (NILP (list
)) continue; /* Try the remaining alternatives. */
13041 newlist
= second_best
= Qnil
;
13042 /* Make a list of the fonts that have the right width. */
13043 for (; CONSP (list
); list
= XCDR (list
))
13049 if (!CONSP (tem
) || NILP (XCAR (tem
)))
13053 newlist
= Fcons (XCAR (tem
), newlist
);
13057 if (!INTEGERP (XCDR (tem
)))
13059 /* Since we have not yet known the size of this font, we
13060 must try slow function call XLoadQueryFont. */
13061 XFontStruct
*thisinfo
;
13064 count
= x_catch_errors (dpy
);
13065 thisinfo
= XLoadQueryFont (dpy
,
13066 XSTRING (XCAR (tem
))->data
);
13067 if (x_had_errors_p (dpy
))
13069 /* This error is perhaps due to insufficient memory on X
13070 server. Let's just ignore it. */
13072 x_clear_errors (dpy
);
13074 x_uncatch_errors (dpy
, count
);
13080 = (thisinfo
->min_bounds
.width
== 0
13082 : make_number (thisinfo
->max_bounds
.width
));
13083 XFreeFont (dpy
, thisinfo
);
13086 /* For unknown reason, the previous call of XListFont had
13087 returned a font which can't be opened. Record the size
13088 as 0 not to try to open it again. */
13089 XCDR (tem
) = make_number (0);
13092 found_size
= XINT (XCDR (tem
));
13093 if (found_size
== size
)
13094 newlist
= Fcons (XCAR (tem
), newlist
);
13095 else if (found_size
> 0)
13097 if (NILP (second_best
))
13099 else if (found_size
< size
)
13101 if (XINT (XCDR (second_best
)) > size
13102 || XINT (XCDR (second_best
)) < found_size
)
13107 if (XINT (XCDR (second_best
)) > size
13108 && XINT (XCDR (second_best
)) > found_size
)
13113 if (!NILP (newlist
))
13115 else if (!NILP (second_best
))
13117 newlist
= Fcons (XCAR (second_best
), Qnil
);
13128 /* Check that FONT is valid on frame F. It is if it can be found in F's
13132 x_check_font (f
, font
)
13137 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13139 xassert (font
!= NULL
);
13141 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
13142 if (dpyinfo
->font_table
[i
].name
13143 && font
== dpyinfo
->font_table
[i
].font
)
13146 xassert (i
< dpyinfo
->n_fonts
);
13149 #endif /* GLYPH_DEBUG != 0 */
13151 /* Set *W to the minimum width, *H to the minimum font height of FONT.
13152 Note: There are (broken) X fonts out there with invalid XFontStruct
13153 min_bounds contents. For example, handa@etl.go.jp reports that
13154 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
13155 have font->min_bounds.width == 0. */
13158 x_font_min_bounds (font
, w
, h
)
13162 *h
= FONT_HEIGHT (font
);
13163 *w
= font
->min_bounds
.width
;
13165 /* Try to handle the case where FONT->min_bounds has invalid
13166 contents. Since the only font known to have invalid min_bounds
13167 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
13169 *w
= font
->max_bounds
.width
;
13173 /* Compute the smallest character width and smallest font height over
13174 all fonts available on frame F. Set the members smallest_char_width
13175 and smallest_font_height in F's x_display_info structure to
13176 the values computed. Value is non-zero if smallest_font_height or
13177 smallest_char_width become smaller than they were before. */
13180 x_compute_min_glyph_bounds (f
)
13184 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13186 int old_width
= dpyinfo
->smallest_char_width
;
13187 int old_height
= dpyinfo
->smallest_font_height
;
13189 dpyinfo
->smallest_font_height
= 100000;
13190 dpyinfo
->smallest_char_width
= 100000;
13192 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
13193 if (dpyinfo
->font_table
[i
].name
)
13195 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
13198 font
= (XFontStruct
*) fontp
->font
;
13199 xassert (font
!= (XFontStruct
*) ~0);
13200 x_font_min_bounds (font
, &w
, &h
);
13202 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
13203 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
13206 xassert (dpyinfo
->smallest_char_width
> 0
13207 && dpyinfo
->smallest_font_height
> 0);
13209 return (dpyinfo
->n_fonts
== 1
13210 || dpyinfo
->smallest_char_width
< old_width
13211 || dpyinfo
->smallest_font_height
< old_height
);
13215 /* Load font named FONTNAME of the size SIZE for frame F, and return a
13216 pointer to the structure font_info while allocating it dynamically.
13217 If SIZE is 0, load any size of font.
13218 If loading is failed, return NULL. */
13221 x_load_font (f
, fontname
, size
)
13223 register char *fontname
;
13226 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13227 Lisp_Object font_names
;
13230 /* Get a list of all the fonts that match this name. Once we
13231 have a list of matching fonts, we compare them against the fonts
13232 we already have by comparing names. */
13233 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
13235 if (!NILP (font_names
))
13240 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
13241 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
13242 if (dpyinfo
->font_table
[i
].name
13243 && (!strcmp (dpyinfo
->font_table
[i
].name
,
13244 XSTRING (XCAR (tail
))->data
)
13245 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
13246 XSTRING (XCAR (tail
))->data
)))
13247 return (dpyinfo
->font_table
+ i
);
13250 /* Load the font and add it to the table. */
13254 struct font_info
*fontp
;
13255 unsigned long value
;
13258 /* If we have found fonts by x_list_font, load one of them. If
13259 not, we still try to load a font by the name given as FONTNAME
13260 because XListFonts (called in x_list_font) of some X server has
13261 a bug of not finding a font even if the font surely exists and
13262 is loadable by XLoadQueryFont. */
13263 if (size
> 0 && !NILP (font_names
))
13264 fontname
= (char *) XSTRING (XCAR (font_names
))->data
;
13267 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
13268 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
13269 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
13271 /* This error is perhaps due to insufficient memory on X
13272 server. Let's just ignore it. */
13274 x_clear_errors (FRAME_X_DISPLAY (f
));
13276 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
13281 /* Find a free slot in the font table. */
13282 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
13283 if (dpyinfo
->font_table
[i
].name
== NULL
)
13286 /* If no free slot found, maybe enlarge the font table. */
13287 if (i
== dpyinfo
->n_fonts
13288 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
13291 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
13292 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
13293 dpyinfo
->font_table
13294 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
13297 fontp
= dpyinfo
->font_table
+ i
;
13298 if (i
== dpyinfo
->n_fonts
)
13299 ++dpyinfo
->n_fonts
;
13301 /* Now fill in the slots of *FONTP. */
13303 fontp
->font
= font
;
13304 fontp
->font_idx
= i
;
13305 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
13306 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
13308 /* Try to get the full name of FONT. Put it in FULL_NAME. */
13310 if (XGetFontProperty (font
, XA_FONT
, &value
))
13312 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
13316 /* Count the number of dashes in the "full name".
13317 If it is too few, this isn't really the font's full name,
13319 In X11R4, the fonts did not come with their canonical names
13330 full_name
= (char *) xmalloc (p
- name
+ 1);
13331 bcopy (name
, full_name
, p
- name
+ 1);
13337 if (full_name
!= 0)
13338 fontp
->full_name
= full_name
;
13340 fontp
->full_name
= fontp
->name
;
13342 fontp
->size
= font
->max_bounds
.width
;
13343 fontp
->height
= FONT_HEIGHT (font
);
13345 if (NILP (font_names
))
13347 /* We come here because of a bug of XListFonts mentioned at
13348 the head of this block. Let's store this information in
13349 the cache for x_list_fonts. */
13350 Lisp_Object lispy_name
= build_string (fontname
);
13351 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
13352 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
13355 XCDR (dpyinfo
->name_list_element
)
13356 = Fcons (Fcons (key
,
13357 Fcons (Fcons (lispy_full_name
,
13358 make_number (fontp
->size
)),
13360 XCDR (dpyinfo
->name_list_element
));
13363 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
13365 XCDR (dpyinfo
->name_list_element
)
13366 = Fcons (Fcons (key
,
13367 Fcons (Fcons (lispy_full_name
,
13368 make_number (fontp
->size
)),
13370 XCDR (dpyinfo
->name_list_element
));
13374 /* The slot `encoding' specifies how to map a character
13375 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
13376 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
13377 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
13378 2:0xA020..0xFF7F). For the moment, we don't know which charset
13379 uses this font. So, we set information in fontp->encoding[1]
13380 which is never used by any charset. If mapping can't be
13381 decided, set FONT_ENCODING_NOT_DECIDED. */
13383 = (font
->max_byte1
== 0
13385 ? (font
->min_char_or_byte2
< 0x80
13386 ? (font
->max_char_or_byte2
< 0x80
13387 ? 0 /* 0x20..0x7F */
13388 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
13389 : 1) /* 0xA0..0xFF */
13391 : (font
->min_byte1
< 0x80
13392 ? (font
->max_byte1
< 0x80
13393 ? (font
->min_char_or_byte2
< 0x80
13394 ? (font
->max_char_or_byte2
< 0x80
13395 ? 0 /* 0x2020..0x7F7F */
13396 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
13397 : 3) /* 0x20A0..0x7FFF */
13398 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
13399 : (font
->min_char_or_byte2
< 0x80
13400 ? (font
->max_char_or_byte2
< 0x80
13401 ? 2 /* 0xA020..0xFF7F */
13402 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
13403 : 1))); /* 0xA0A0..0xFFFF */
13405 fontp
->baseline_offset
13406 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
13407 ? (long) value
: 0);
13408 fontp
->relative_compose
13409 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
13410 ? (long) value
: 0);
13411 fontp
->default_ascent
13412 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
13413 ? (long) value
: 0);
13415 /* Set global flag fonts_changed_p to non-zero if the font loaded
13416 has a character with a smaller width than any other character
13417 before, or if the font loaded has a smalle>r height than any
13418 other font loaded before. If this happens, it will make a
13419 glyph matrix reallocation necessary. */
13420 fonts_changed_p
= x_compute_min_glyph_bounds (f
);
13427 /* Return a pointer to struct font_info of a font named FONTNAME for
13428 frame F. If no such font is loaded, return NULL. */
13431 x_query_font (f
, fontname
)
13433 register char *fontname
;
13435 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
13438 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
13439 if (dpyinfo
->font_table
[i
].name
13440 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
13441 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
13442 return (dpyinfo
->font_table
+ i
);
13447 /* Find a CCL program for a font specified by FONTP, and set the member
13448 `encoder' of the structure. */
13451 x_find_ccl_program (fontp
)
13452 struct font_info
*fontp
;
13454 Lisp_Object list
, elt
;
13457 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
13461 && STRINGP (XCAR (elt
))
13462 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
13464 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
13471 struct ccl_program
*ccl
13472 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
13474 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
13477 fontp
->font_encoder
= ccl
;
13483 /***********************************************************************
13485 ***********************************************************************/
13487 #ifdef USE_X_TOOLKIT
13488 static XrmOptionDescRec emacs_options
[] = {
13489 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
13490 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
13492 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
13493 XrmoptionSepArg
, NULL
},
13494 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
13496 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13497 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13498 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
13499 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
13500 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
13501 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
13502 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
13504 #endif /* USE_X_TOOLKIT */
13506 static int x_initialized
;
13508 #ifdef MULTI_KBOARD
13509 /* Test whether two display-name strings agree up to the dot that separates
13510 the screen number from the server number. */
13512 same_x_server (name1
, name2
)
13513 char *name1
, *name2
;
13515 int seen_colon
= 0;
13516 unsigned char *system_name
= XSTRING (Vsystem_name
)->data
;
13517 int system_name_length
= strlen (system_name
);
13518 int length_until_period
= 0;
13520 while (system_name
[length_until_period
] != 0
13521 && system_name
[length_until_period
] != '.')
13522 length_until_period
++;
13524 /* Treat `unix' like an empty host name. */
13525 if (! strncmp (name1
, "unix:", 5))
13527 if (! strncmp (name2
, "unix:", 5))
13529 /* Treat this host's name like an empty host name. */
13530 if (! strncmp (name1
, system_name
, system_name_length
)
13531 && name1
[system_name_length
] == ':')
13532 name1
+= system_name_length
;
13533 if (! strncmp (name2
, system_name
, system_name_length
)
13534 && name2
[system_name_length
] == ':')
13535 name2
+= system_name_length
;
13536 /* Treat this host's domainless name like an empty host name. */
13537 if (! strncmp (name1
, system_name
, length_until_period
)
13538 && name1
[length_until_period
] == ':')
13539 name1
+= length_until_period
;
13540 if (! strncmp (name2
, system_name
, length_until_period
)
13541 && name2
[length_until_period
] == ':')
13542 name2
+= length_until_period
;
13544 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
13548 if (seen_colon
&& *name1
== '.')
13552 && (*name1
== '.' || *name1
== '\0')
13553 && (*name2
== '.' || *name2
== '\0'));
13557 struct x_display_info
*
13558 x_term_init (display_name
, xrm_option
, resource_name
)
13559 Lisp_Object display_name
;
13561 char *resource_name
;
13565 struct x_display_info
*dpyinfo
;
13570 if (!x_initialized
)
13576 #ifdef USE_X_TOOLKIT
13577 /* weiner@footloose.sps.mot.com reports that this causes
13579 X protocol error: BadAtom (invalid Atom parameter)
13580 on protocol request 18skiloaf.
13581 So let's not use it until R6. */
13582 #ifdef HAVE_X11XTR6
13583 XtSetLanguageProc (NULL
, NULL
, NULL
);
13594 argv
[argc
++] = "-xrm";
13595 argv
[argc
++] = xrm_option
;
13597 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
13598 resource_name
, EMACS_CLASS
,
13599 emacs_options
, XtNumber (emacs_options
),
13602 #ifdef HAVE_X11XTR6
13603 /* I think this is to compensate for XtSetLanguageProc. */
13608 #else /* not USE_X_TOOLKIT */
13610 XSetLocaleModifiers ("");
13612 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
13613 #endif /* not USE_X_TOOLKIT */
13615 /* Detect failure. */
13622 /* We have definitely succeeded. Record the new connection. */
13624 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
13625 bzero (dpyinfo
, sizeof *dpyinfo
);
13627 #ifdef MULTI_KBOARD
13629 struct x_display_info
*share
;
13632 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
13633 share
= share
->next
, tail
= XCDR (tail
))
13634 if (same_x_server (XSTRING (XCAR (XCAR (tail
)))->data
,
13635 XSTRING (display_name
)->data
))
13638 dpyinfo
->kboard
= share
->kboard
;
13641 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
13642 init_kboard (dpyinfo
->kboard
);
13643 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
13645 char *vendor
= ServerVendor (dpy
);
13647 dpyinfo
->kboard
->Vsystem_key_alist
13648 = call1 (Qvendor_specific_keysyms
,
13649 build_string (vendor
? vendor
: ""));
13653 dpyinfo
->kboard
->next_kboard
= all_kboards
;
13654 all_kboards
= dpyinfo
->kboard
;
13655 /* Don't let the initial kboard remain current longer than necessary.
13656 That would cause problems if a file loaded on startup tries to
13657 prompt in the mini-buffer. */
13658 if (current_kboard
== initial_kboard
)
13659 current_kboard
= dpyinfo
->kboard
;
13661 dpyinfo
->kboard
->reference_count
++;
13665 /* Put this display on the chain. */
13666 dpyinfo
->next
= x_display_list
;
13667 x_display_list
= dpyinfo
;
13669 /* Put it on x_display_name_list as well, to keep them parallel. */
13670 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
13671 x_display_name_list
);
13672 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
13674 dpyinfo
->display
= dpy
;
13677 XSetAfterFunction (x_current_display
, x_trace_wire
);
13681 = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name
))
13682 + STRING_BYTES (XSTRING (Vsystem_name
))
13684 sprintf (dpyinfo
->x_id_name
, "%s@%s",
13685 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
13687 /* Figure out which modifier bits mean what. */
13688 x_find_modifier_meanings (dpyinfo
);
13690 /* Get the scroll bar cursor. */
13691 dpyinfo
->vertical_scroll_bar_cursor
13692 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
13694 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
13695 resource_name
, EMACS_CLASS
);
13696 #ifdef HAVE_XRMSETDATABASE
13697 XrmSetDatabase (dpyinfo
->display
, xrdb
);
13699 dpyinfo
->display
->db
= xrdb
;
13701 /* Put the rdb where we can find it in a way that works on
13703 dpyinfo
->xrdb
= xrdb
;
13705 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
13706 DefaultScreen (dpyinfo
->display
));
13707 select_visual (dpyinfo
);
13708 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
13709 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
13710 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
13711 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
13712 dpyinfo
->grabbed
= 0;
13713 dpyinfo
->reference_count
= 0;
13714 dpyinfo
->icon_bitmap_id
= -1;
13715 dpyinfo
->font_table
= NULL
;
13716 dpyinfo
->n_fonts
= 0;
13717 dpyinfo
->font_table_size
= 0;
13718 dpyinfo
->bitmaps
= 0;
13719 dpyinfo
->bitmaps_size
= 0;
13720 dpyinfo
->bitmaps_last
= 0;
13721 dpyinfo
->scratch_cursor_gc
= 0;
13722 dpyinfo
->mouse_face_mouse_frame
= 0;
13723 dpyinfo
->mouse_face_deferred_gc
= 0;
13724 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
13725 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
13726 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
13727 dpyinfo
->mouse_face_window
= Qnil
;
13728 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
13729 dpyinfo
->mouse_face_defer
= 0;
13730 dpyinfo
->x_focus_frame
= 0;
13731 dpyinfo
->x_focus_event_frame
= 0;
13732 dpyinfo
->x_highlight_frame
= 0;
13733 dpyinfo
->image_cache
= make_image_cache ();
13735 /* See if a private colormap is requested. */
13736 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
13738 if (dpyinfo
->visual
->class == PseudoColor
)
13741 value
= display_x_get_resource (dpyinfo
,
13742 build_string ("privateColormap"),
13743 build_string ("PrivateColormap"),
13745 if (STRINGP (value
)
13746 && (!strcmp (XSTRING (value
)->data
, "true")
13747 || !strcmp (XSTRING (value
)->data
, "on")))
13748 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
13752 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
13753 dpyinfo
->visual
, AllocNone
);
13756 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
13757 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
13758 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
13759 dpyinfo
->resy
= pixels
* 25.4 / mm
;
13760 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
13761 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
13762 dpyinfo
->resx
= pixels
* 25.4 / mm
;
13765 dpyinfo
->Xatom_wm_protocols
13766 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
13767 dpyinfo
->Xatom_wm_take_focus
13768 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
13769 dpyinfo
->Xatom_wm_save_yourself
13770 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
13771 dpyinfo
->Xatom_wm_delete_window
13772 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
13773 dpyinfo
->Xatom_wm_change_state
13774 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
13775 dpyinfo
->Xatom_wm_configure_denied
13776 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
13777 dpyinfo
->Xatom_wm_window_moved
13778 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
13779 dpyinfo
->Xatom_editres
13780 = XInternAtom (dpyinfo
->display
, "Editres", False
);
13781 dpyinfo
->Xatom_CLIPBOARD
13782 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
13783 dpyinfo
->Xatom_TIMESTAMP
13784 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
13785 dpyinfo
->Xatom_TEXT
13786 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
13787 dpyinfo
->Xatom_COMPOUND_TEXT
13788 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
13789 dpyinfo
->Xatom_DELETE
13790 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
13791 dpyinfo
->Xatom_MULTIPLE
13792 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
13793 dpyinfo
->Xatom_INCR
13794 = XInternAtom (dpyinfo
->display
, "INCR", False
);
13795 dpyinfo
->Xatom_EMACS_TMP
13796 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
13797 dpyinfo
->Xatom_TARGETS
13798 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
13799 dpyinfo
->Xatom_NULL
13800 = XInternAtom (dpyinfo
->display
, "NULL", False
);
13801 dpyinfo
->Xatom_ATOM_PAIR
13802 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
13803 /* For properties of font. */
13804 dpyinfo
->Xatom_PIXEL_SIZE
13805 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
13806 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
13807 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
13808 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
13809 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
13810 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
13811 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
13813 /* Ghostscript support. */
13814 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
13815 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
13817 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
13820 dpyinfo
->cut_buffers_initialized
= 0;
13822 connection
= ConnectionNumber (dpyinfo
->display
);
13823 dpyinfo
->connection
= connection
;
13828 null_bits
[0] = 0x00;
13830 dpyinfo
->null_pixel
13831 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
13832 null_bits
, 1, 1, (long) 0, (long) 0,
13837 extern int gray_bitmap_width
, gray_bitmap_height
;
13838 extern char *gray_bitmap_bits
;
13840 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
13842 gray_bitmap_width
, gray_bitmap_height
,
13843 (unsigned long) 1, (unsigned long) 0, 1);
13847 xim_initialize (dpyinfo
, resource_name
);
13850 #ifdef subprocesses
13851 /* This is only needed for distinguishing keyboard and process input. */
13852 if (connection
!= 0)
13853 add_keyboard_wait_descriptor (connection
);
13856 #ifndef F_SETOWN_BUG
13858 #ifdef F_SETOWN_SOCK_NEG
13859 /* stdin is a socket here */
13860 fcntl (connection
, F_SETOWN
, -getpid ());
13861 #else /* ! defined (F_SETOWN_SOCK_NEG) */
13862 fcntl (connection
, F_SETOWN
, getpid ());
13863 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
13864 #endif /* ! defined (F_SETOWN) */
13865 #endif /* F_SETOWN_BUG */
13868 if (interrupt_input
)
13869 init_sigio (connection
);
13870 #endif /* ! defined (SIGIO) */
13873 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
13874 /* Make sure that we have a valid font for dialog boxes
13875 so that Xt does not crash. */
13877 Display
*dpy
= dpyinfo
->display
;
13878 XrmValue d
, fr
, to
;
13882 d
.addr
= (XPointer
)&dpy
;
13883 d
.size
= sizeof (Display
*);
13884 fr
.addr
= XtDefaultFont
;
13885 fr
.size
= sizeof (XtDefaultFont
);
13886 to
.size
= sizeof (Font
*);
13887 to
.addr
= (XPointer
)&font
;
13888 count
= x_catch_errors (dpy
);
13889 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
13891 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
13892 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
13893 x_uncatch_errors (dpy
, count
);
13898 /* See if we should run in synchronous mode. This is useful
13899 for debugging X code. */
13902 value
= display_x_get_resource (dpyinfo
,
13903 build_string ("synchronous"),
13904 build_string ("Synchronous"),
13906 if (STRINGP (value
)
13907 && (!strcmp (XSTRING (value
)->data
, "true")
13908 || !strcmp (XSTRING (value
)->data
, "on")))
13909 XSynchronize (dpyinfo
->display
, True
);
13917 /* Get rid of display DPYINFO, assuming all frames are already gone,
13918 and without sending any more commands to the X server. */
13921 x_delete_display (dpyinfo
)
13922 struct x_display_info
*dpyinfo
;
13924 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
13926 /* Discard this display from x_display_name_list and x_display_list.
13927 We can't use Fdelq because that can quit. */
13928 if (! NILP (x_display_name_list
)
13929 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
13930 x_display_name_list
= XCDR (x_display_name_list
);
13935 tail
= x_display_name_list
;
13936 while (CONSP (tail
) && CONSP (XCDR (tail
)))
13938 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
13940 XCDR (tail
) = XCDR (XCDR (tail
));
13943 tail
= XCDR (tail
);
13947 if (next_noop_dpyinfo
== dpyinfo
)
13948 next_noop_dpyinfo
= dpyinfo
->next
;
13950 if (x_display_list
== dpyinfo
)
13951 x_display_list
= dpyinfo
->next
;
13954 struct x_display_info
*tail
;
13956 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
13957 if (tail
->next
== dpyinfo
)
13958 tail
->next
= tail
->next
->next
;
13961 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
13962 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
13963 XrmDestroyDatabase (dpyinfo
->xrdb
);
13966 #ifdef MULTI_KBOARD
13967 if (--dpyinfo
->kboard
->reference_count
== 0)
13968 delete_kboard (dpyinfo
->kboard
);
13972 xim_close_dpy (dpyinfo
);
13975 xfree (dpyinfo
->font_table
);
13976 xfree (dpyinfo
->x_id_name
);
13977 xfree (dpyinfo
->color_cells
);
13982 /* Set up use of X before we make the first connection. */
13984 static struct redisplay_interface x_redisplay_interface
=
13989 x_clear_end_of_line
,
13991 x_after_update_window_line
,
13992 x_update_window_begin
,
13993 x_update_window_end
,
13996 x_clear_mouse_face
,
13997 x_get_glyph_overhangs
,
13998 x_fix_overlapping_area
14004 rif
= &x_redisplay_interface
;
14006 clear_frame_hook
= x_clear_frame
;
14007 ins_del_lines_hook
= x_ins_del_lines
;
14008 change_line_highlight_hook
= x_change_line_highlight
;
14009 delete_glyphs_hook
= x_delete_glyphs
;
14010 ring_bell_hook
= XTring_bell
;
14011 reset_terminal_modes_hook
= XTreset_terminal_modes
;
14012 set_terminal_modes_hook
= XTset_terminal_modes
;
14013 update_begin_hook
= x_update_begin
;
14014 update_end_hook
= x_update_end
;
14015 set_terminal_window_hook
= XTset_terminal_window
;
14016 read_socket_hook
= XTread_socket
;
14017 frame_up_to_date_hook
= XTframe_up_to_date
;
14018 reassert_line_highlight_hook
= XTreassert_line_highlight
;
14019 mouse_position_hook
= XTmouse_position
;
14020 frame_rehighlight_hook
= XTframe_rehighlight
;
14021 frame_raise_lower_hook
= XTframe_raise_lower
;
14022 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
14023 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
14024 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
14025 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
14026 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
14028 scroll_region_ok
= 1; /* we'll scroll partial frames */
14029 char_ins_del_ok
= 1;
14030 line_ins_del_ok
= 1; /* we'll just blt 'em */
14031 fast_clear_end_of_line
= 1; /* X does this well */
14032 memory_below_frame
= 0; /* we don't remember what scrolls
14037 last_tool_bar_item
= -1;
14038 any_help_event_p
= 0;
14040 /* Try to use interrupt input; if we can't, then start polling. */
14041 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
14043 #ifdef USE_X_TOOLKIT
14044 XtToolkitInitialize ();
14045 Xt_app_con
= XtCreateApplicationContext ();
14046 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
14048 /* Install an asynchronous timer that processes Xt timeout events
14049 every 0.1s. This is necessary because some widget sets use
14050 timeouts internally, for example the LessTif menu bar, or the
14051 Xaw3d scroll bar. When Xt timouts aren't processed, these
14052 widgets don't behave normally. */
14054 EMACS_TIME interval
;
14055 EMACS_SET_SECS_USECS (interval
, 0, 100000);
14056 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
14060 #ifdef USE_TOOLKIT_SCROLL_BARS
14061 xaw3d_arrow_scroll
= False
;
14062 xaw3d_pick_top
= True
;
14065 /* Note that there is no real way portable across R3/R4 to get the
14066 original error handler. */
14067 XSetErrorHandler (x_error_handler
);
14068 XSetIOErrorHandler (x_io_error_quitter
);
14070 /* Disable Window Change signals; they are handled by X events. */
14072 signal (SIGWINCH
, SIG_DFL
);
14073 #endif /* ! defined (SIGWINCH) */
14075 signal (SIGPIPE
, x_connection_signal
);
14082 staticpro (&x_error_message_string
);
14083 x_error_message_string
= Qnil
;
14085 staticpro (&x_display_name_list
);
14086 x_display_name_list
= Qnil
;
14088 staticpro (&last_mouse_scroll_bar
);
14089 last_mouse_scroll_bar
= Qnil
;
14091 staticpro (&Qvendor_specific_keysyms
);
14092 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
14094 staticpro (&last_mouse_press_frame
);
14095 last_mouse_press_frame
= Qnil
;
14098 staticpro (&help_echo
);
14099 help_echo_object
= Qnil
;
14100 staticpro (&help_echo_object
);
14101 help_echo_window
= Qnil
;
14102 staticpro (&help_echo_window
);
14103 previous_help_echo
= Qnil
;
14104 staticpro (&previous_help_echo
);
14105 help_echo_pos
= -1;
14107 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
14108 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
14109 For example, if a block cursor is over a tab, it will be drawn as\n\
14110 wide as that tab on the display.");
14111 x_stretch_cursor_p
= 0;
14113 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
14114 "What X toolkit scroll bars Emacs uses.\n\
14115 A value of nil means Emacs doesn't use X toolkit scroll bars.\n\
14116 Otherwise, value is a symbol describing the X toolkit.");
14117 #ifdef USE_TOOLKIT_SCROLL_BARS
14119 Vx_toolkit_scroll_bars
= intern ("motif");
14120 #elif defined HAVE_XAW3D
14121 Vx_toolkit_scroll_bars
= intern ("xaw3d");
14123 Vx_toolkit_scroll_bars
= intern ("xaw");
14126 Vx_toolkit_scroll_bars
= Qnil
;
14129 staticpro (&last_mouse_motion_frame
);
14130 last_mouse_motion_frame
= Qnil
;
14133 #endif /* not HAVE_X_WINDOWS */