1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
23 /* Xt features made by Fred Pierresteguy. */
27 /* On 4.3 these lose if they come after xterm.h. */
28 /* Putting these at the beginning seems to be standard for other .c files. */
36 #include "blockinput.h"
38 /* Need syssignal.h for various externs and definitions that may be required
39 by some configurations for calls to signal later in this source file. */
40 #include "syssignal.h"
42 /* This may include sys/types.h, and that somehow loses
43 if this is not done before the other system files. */
45 #include <X11/cursorfont.h>
48 /* Load sys/types.h if not already loaded.
49 In some systems loading it twice is suicidal. */
51 #include <sys/types.h>
56 #include <sys/ioctl.h>
57 #endif /* ! defined (BSD_SYSTEM) */
62 #ifndef INCLUDED_FCNTL
69 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
70 /* #include <sys/param.h> */
75 #include "dispextern.h"
77 #include "termhooks.h"
89 #include "intervals.h"
94 #include <X11/Shell.h>
97 #include <sys/types.h>
98 #ifdef HAVE_SYS_TIME_H
107 extern void free_frame_menubar ();
108 extern FRAME_PTR
x_menubar_window_to_frame ();
110 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
112 extern void _XEditResCheckMessages ();
113 #endif /* not NO_EDITRES */
115 /* Include toolkit specific headers for the scroll bar widget. */
117 #ifdef USE_TOOLKIT_SCROLL_BARS
118 #if defined USE_MOTIF
119 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
120 #include <Xm/ScrollBar.h>
121 #include <Xm/ScrollBarP.h>
122 #else /* !USE_MOTIF i.e. use Xaw */
125 #include <X11/Xaw3d/Simple.h>
126 #include <X11/Xaw3d/Scrollbar.h>
127 #define ARROW_SCROLLBAR
128 #include <X11/Xaw3d/ScrollbarP.h>
129 #else /* !HAVE_XAW3D */
130 #include <X11/Xaw/Simple.h>
131 #include <X11/Xaw/Scrollbar.h>
132 #endif /* !HAVE_XAW3D */
134 #define XtNpickTop "pickTop"
135 #endif /* !XtNpickTop */
136 #endif /* !USE_MOTIF */
137 #endif /* USE_TOOLKIT_SCROLL_BARS */
139 #endif /* USE_X_TOOLKIT */
141 #ifndef USE_X_TOOLKIT
142 #define x_any_window_to_frame x_window_to_frame
143 #define x_top_window_to_frame x_window_to_frame
148 #ifndef XtNinitialState
149 #define XtNinitialState "initialState"
154 /* memmove will be defined as a macro in Xfuncs.h unless
155 <string.h> is included beforehand. The declaration for memmove in
156 <string.h> will cause a syntax error when Xfuncs.h later includes it. */
161 #define min(a,b) ((a) < (b) ? (a) : (b))
164 #define max(a,b) ((a) > (b) ? (a) : (b))
167 #define abs(x) ((x) < 0 ? -(x) : (x))
169 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
172 /* Bitmaps for truncated lines. */
177 LEFT_TRUNCATION_BITMAP
,
178 RIGHT_TRUNCATION_BITMAP
,
179 OVERLAY_ARROW_BITMAP
,
180 CONTINUED_LINE_BITMAP
,
181 CONTINUATION_LINE_BITMAP
,
185 /* Bitmap drawn to indicate lines not displaying text if
186 `indicate-empty-lines' is non-nil. */
190 static unsigned char zv_bits
[] = {
191 0x00, 0x00, 0x1e, 0x1e, 0x1e, 0x1e, 0x00, 0x00};
193 /* An arrow like this: `<-'. */
196 #define left_height 8
197 static unsigned char left_bits
[] = {
198 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
200 /* Right truncation arrow bitmap `->'. */
202 #define right_width 8
203 #define right_height 8
204 static unsigned char right_bits
[] = {
205 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
207 /* Marker for continued lines. */
209 #define continued_width 8
210 #define continued_height 8
211 static unsigned char continued_bits
[] = {
212 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
214 /* Marker for continuation lines. */
216 #define continuation_width 8
217 #define continuation_height 8
218 static unsigned char continuation_bits
[] = {
219 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
221 /* Overlay arrow bitmap. */
227 static unsigned char ov_bits
[] = {
228 0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
230 /* A triangular arrow. */
233 static unsigned char ov_bits
[] = {
234 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
238 extern Lisp_Object Qhelp_echo
;
241 /* Non-zero means Emacs uses toolkit scroll bars. */
243 int x_toolkit_scroll_bars_p
;
245 /* If a string, XTread_socket generates an event to display that string.
246 (The display is done in read_char.) */
248 static Lisp_Object help_echo
;
250 /* Temporary variable for XTread_socket. */
252 static Lisp_Object previous_help_echo
;
254 /* Non-zero means that a HELP_EVENT has been generated since Emacs
257 static int any_help_event_p
;
259 /* Non-zero means draw block and hollow cursor as wide as the glyph
260 under it. For example, if a block cursor is over a tab, it will be
261 drawn as wide as that tab on the display. */
263 int x_stretch_cursor_p
;
265 /* This is a chain of structures for all the X displays currently in
268 struct x_display_info
*x_display_list
;
270 /* This is a list of cons cells, each of the form (NAME
271 . FONT-LIST-CACHE), one for each element of x_display_list and in
272 the same order. NAME is the name of the frame. FONT-LIST-CACHE
273 records previous values returned by x-list-fonts. */
275 Lisp_Object x_display_name_list
;
277 /* Frame being updated by update_frame. This is declared in term.c.
278 This is set by update_begin and looked at by all the XT functions.
279 It is zero while not inside an update. In that case, the XT
280 functions assume that `selected_frame' is the frame to apply to. */
282 extern struct frame
*updating_frame
;
284 extern int waiting_for_input
;
286 /* This is a frame waiting to be auto-raised, within XTread_socket. */
288 struct frame
*pending_autoraise_frame
;
291 /* The application context for Xt use. */
292 XtAppContext Xt_app_con
;
293 static String Xt_default_resources
[] = {0};
294 #endif /* USE_X_TOOLKIT */
296 /* Nominal cursor position -- where to draw output.
297 HPOS and VPOS are window relative glyph matrix coordinates.
298 X and Y are window relative pixel coordinates. */
300 struct cursor_pos output_cursor
;
302 /* Non-zero means user is interacting with a toolkit scroll bar. */
304 static int toolkit_scroll_bar_interaction
;
308 Formerly, we used PointerMotionHintMask (in standard_event_mask)
309 so that we would have to call XQueryPointer after each MotionNotify
310 event to ask for another such event. However, this made mouse tracking
311 slow, and there was a bug that made it eventually stop.
313 Simply asking for MotionNotify all the time seems to work better.
315 In order to avoid asking for motion events and then throwing most
316 of them away or busy-polling the server for mouse positions, we ask
317 the server for pointer motion hints. This means that we get only
318 one event per group of mouse movements. "Groups" are delimited by
319 other kinds of events (focus changes and button clicks, for
320 example), or by XQueryPointer calls; when one of these happens, we
321 get another MotionNotify event the next time the mouse moves. This
322 is at least as efficient as getting motion events when mouse
323 tracking is on, and I suspect only negligibly worse when tracking
326 /* Where the mouse was last time we reported a mouse event. */
328 FRAME_PTR last_mouse_frame
;
329 static XRectangle last_mouse_glyph
;
330 static Lisp_Object last_mouse_press_frame
;
332 /* The scroll bar in which the last X motion event occurred.
334 If the last X motion event occurred in a scroll bar, we set this so
335 XTmouse_position can know whether to report a scroll bar motion or
338 If the last X motion event didn't occur in a scroll bar, we set
339 this to Qnil, to tell XTmouse_position to return an ordinary motion
342 static Lisp_Object last_mouse_scroll_bar
;
344 /* This is a hack. We would really prefer that XTmouse_position would
345 return the time associated with the position it returns, but there
346 doesn't seem to be any way to wrest the time-stamp from the server
347 along with the position query. So, we just keep track of the time
348 of the last movement we received, and return that in hopes that
349 it's somewhat accurate. */
351 static Time last_mouse_movement_time
;
353 /* Incremented by XTread_socket whenever it really tries to read
357 static int volatile input_signal_count
;
359 static int input_signal_count
;
362 /* Used locally within XTread_socket. */
364 static int x_noop_count
;
366 /* Initial values of argv and argc. */
368 extern char **initial_argv
;
369 extern int initial_argc
;
371 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
373 /* Tells if a window manager is present or not. */
375 extern Lisp_Object Vx_no_window_manager
;
377 extern Lisp_Object Qface
, Qmouse_face
;
381 /* A mask of extra modifier bits to put into every keyboard char. */
383 extern int extra_keyboard_modifiers
;
385 static Lisp_Object Qvendor_specific_keysyms
;
387 extern XrmDatabase
x_load_resources ();
388 extern Lisp_Object
x_icon_type ();
391 /* Enumeration for overriding/changing the face to use for drawing
392 glyphs in x_draw_glyphs. */
394 enum draw_glyphs_face
404 static void x_update_window_end
P_ ((struct window
*, int));
405 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
406 void x_delete_display
P_ ((struct x_display_info
*));
407 static unsigned int x_x_to_emacs_modifiers
P_ ((struct x_display_info
*,
409 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
411 static void set_output_cursor
P_ ((struct cursor_pos
*));
412 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
413 int *, int *, int *));
414 static void note_mode_line_highlight
P_ ((struct window
*, int, int));
415 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
416 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
417 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
418 static void x_handle_tool_bar_click
P_ ((struct frame
*, XButtonEvent
*));
419 static void show_mouse_face
P_ ((struct x_display_info
*,
420 enum draw_glyphs_face
));
421 static int x_io_error_quitter
P_ ((Display
*));
422 int x_catch_errors
P_ ((Display
*));
423 void x_uncatch_errors
P_ ((Display
*, int));
424 void x_lower_frame
P_ ((struct frame
*));
425 void x_scroll_bar_clear
P_ ((struct frame
*));
426 int x_had_errors_p
P_ ((Display
*));
427 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
428 void x_raise_frame
P_ ((struct frame
*));
429 void x_set_window_size
P_ ((struct frame
*, int, int, int));
430 void x_wm_set_window_state
P_ ((struct frame
*, int));
431 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
432 void x_initialize
P_ ((void));
433 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
434 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
435 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
437 enum draw_glyphs_face
));
438 static void x_update_end
P_ ((struct frame
*));
439 static void XTframe_up_to_date
P_ ((struct frame
*));
440 static void XTreassert_line_highlight
P_ ((int, int));
441 static void x_change_line_highlight
P_ ((int, int, int, int));
442 static void XTset_terminal_modes
P_ ((void));
443 static void XTreset_terminal_modes
P_ ((void));
444 static void XTcursor_to
P_ ((int, int, int, int));
445 static void x_write_glyphs
P_ ((struct glyph
*, int));
446 static void x_clear_end_of_line
P_ ((int));
447 static void x_clear_frame
P_ ((void));
448 static void x_clear_cursor
P_ ((struct window
*));
449 static void frame_highlight
P_ ((struct frame
*));
450 static void frame_unhighlight
P_ ((struct frame
*));
451 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
452 static void XTframe_rehighlight
P_ ((struct frame
*));
453 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
454 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
455 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int));
456 static int x_intersect_rectangles
P_ ((XRectangle
*, XRectangle
*,
458 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
459 static void expose_window_tree
P_ ((struct window
*, XRectangle
*));
460 static void expose_window
P_ ((struct window
*, XRectangle
*));
461 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
462 XRectangle
*, enum glyph_row_area
));
463 static void expose_line
P_ ((struct window
*, struct glyph_row
*,
465 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
466 static void x_update_window_cursor
P_ ((struct window
*, int));
467 static void x_erase_phys_cursor
P_ ((struct window
*));
468 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
469 static void x_draw_bitmap
P_ ((struct window
*, struct glyph_row
*,
472 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
474 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, XRectangle
*));
475 static void x_draw_row_bitmaps
P_ ((struct window
*, struct glyph_row
*));
476 static void note_overwritten_text_cursor
P_ ((struct window
*, int, int));
477 static void x_flush
P_ ((struct frame
*f
));
480 /* Flush display of frame F, or of all frames if F is null. */
489 Lisp_Object rest
, frame
;
490 FOR_EACH_FRAME (rest
, frame
)
491 x_flush (XFRAME (frame
));
493 else if (FRAME_X_P (f
))
494 XFlush (FRAME_X_DISPLAY (f
));
499 /* Remove calls to XFlush by defining XFlush to an empty replacement.
500 Calls to XFlush should be unnecessary because the X output buffer
501 is flushed automatically as needed by calls to XPending,
502 XNextEvent, or XWindowEvent according to the XFlush man page.
503 XTread_socket calls XPending. Removing XFlush improves
506 #define XFlush(DISPLAY) (void) 0
509 /***********************************************************************
511 ***********************************************************************/
515 /* This is a function useful for recording debugging information about
516 the sequence of occurrences in this file. */
524 struct record event_record
[100];
526 int event_record_index
;
528 record_event (locus
, type
)
532 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
533 event_record_index
= 0;
535 event_record
[event_record_index
].locus
= locus
;
536 event_record
[event_record_index
].type
= type
;
537 event_record_index
++;
544 /* Return the struct x_display_info corresponding to DPY. */
546 struct x_display_info
*
547 x_display_info_for_display (dpy
)
550 struct x_display_info
*dpyinfo
;
552 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
553 if (dpyinfo
->display
== dpy
)
561 /***********************************************************************
562 Starting and ending an update
563 ***********************************************************************/
565 /* Start an update of frame F. This function is installed as a hook
566 for update_begin, i.e. it is called when update_begin is called.
567 This function is called prior to calls to x_update_window_begin for
568 each window being updated. Currently, there is nothing to do here
569 because all interesting stuff is done on a window basis. */
579 /* Start update of window W. Set the global variable updated_window
580 to the window being updated and set output_cursor to the cursor
584 x_update_window_begin (w
)
587 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
588 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
591 set_output_cursor (&w
->cursor
);
595 if (f
== display_info
->mouse_face_mouse_frame
)
597 /* Don't do highlighting for mouse motion during the update. */
598 display_info
->mouse_face_defer
= 1;
600 /* If F needs to be redrawn, simply forget about any prior mouse
602 if (FRAME_GARBAGED_P (f
))
603 display_info
->mouse_face_window
= Qnil
;
605 /* Can we tell that this update does not affect the window
606 where the mouse highlight is? If so, no need to turn off.
607 Likewise, don't do anything if the frame is garbaged;
608 in that case, the frame's current matrix that we would use
609 is all wrong, and we will redisplay that line anyway. */
610 if (!NILP (display_info
->mouse_face_window
)
611 && w
== XWINDOW (display_info
->mouse_face_window
))
615 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
616 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
619 if (i
< w
->desired_matrix
->nrows
)
620 clear_mouse_face (display_info
);
628 /* Draw a vertical window border to the right of window W if W doesn't
629 have vertical scroll bars. */
632 x_draw_vertical_border (w
)
635 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
637 /* Redraw borders between horizontally adjacent windows. Don't
638 do it for frames with vertical scroll bars because either the
639 right scroll bar of a window, or the left scroll bar of its
640 neighbor will suffice as a border. */
641 if (!WINDOW_RIGHTMOST_P (w
)
642 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
646 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
647 x1
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
);
650 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
651 f
->output_data
.x
->normal_gc
, x1
, y0
, x1
, y1
);
656 /* End update of window W (which is equal to updated_window). Draw
657 vertical borders between horizontally adjacent windows, and display
658 W's cursor if CURSOR_ON_P is non-zero. W may be a menu bar
659 pseudo-window in case we don't have X toolkit support. Such
660 windows don't have a cursor, so don't display it here. */
663 x_update_window_end (w
, cursor_on_p
)
667 if (!w
->pseudo_window_p
)
671 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
673 output_cursor
.x
, output_cursor
.y
);
674 x_draw_vertical_border (w
);
678 updated_window
= NULL
;
682 /* End update of frame F. This function is installed as a hook in
689 /* Mouse highlight may be displayed again. */
690 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
693 XFlush (FRAME_X_DISPLAY (f
));
698 /* This function is called from various places in xdisp.c whenever a
699 complete update has been performed. The global variable
700 updated_window is not available here. */
703 XTframe_up_to_date (f
)
708 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
709 if (dpyinfo
->mouse_face_deferred_gc
710 || f
== dpyinfo
->mouse_face_mouse_frame
)
713 if (dpyinfo
->mouse_face_mouse_frame
)
714 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
715 dpyinfo
->mouse_face_mouse_x
,
716 dpyinfo
->mouse_face_mouse_y
);
717 dpyinfo
->mouse_face_deferred_gc
= 0;
724 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
725 arrow bitmaps, or clear the areas where they would be displayed
726 before DESIRED_ROW is made current. The window being updated is
727 found in updated_window. This function It is called from
728 update_window_line only if it is known that there are differences
729 between bitmaps to be drawn between current row and DESIRED_ROW. */
732 x_after_update_window_line (desired_row
)
733 struct glyph_row
*desired_row
;
735 struct window
*w
= updated_window
;
739 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
742 x_draw_row_bitmaps (w
, desired_row
);
744 /* When a window has disappeared, make sure that no rest of
745 full-width rows stays visible in the internal border. */
746 if (windows_or_buffers_changed
)
748 struct frame
*f
= XFRAME (w
->frame
);
749 int width
= FRAME_INTERNAL_BORDER_WIDTH (f
);
750 int height
= desired_row
->visible_height
;
751 int x
= (window_box_right (w
, -1)
752 + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
));
753 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
755 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
756 x
, y
, width
, height
, False
);
764 /* Draw the bitmap WHICH in one of the areas to the left or right of
765 window W. ROW is the glyph row for which to display the bitmap; it
766 determines the vertical position at which the bitmap has to be
770 x_draw_bitmap (w
, row
, which
)
772 struct glyph_row
*row
;
773 enum bitmap_type which
;
775 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
776 Display
*display
= FRAME_X_DISPLAY (f
);
777 Window window
= FRAME_X_WINDOW (f
);
781 GC gc
= f
->output_data
.x
->normal_gc
;
783 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
785 /* Must clip because of partially visible lines. */
786 x_clip_to_row (w
, row
, gc
, 1);
790 case LEFT_TRUNCATION_BITMAP
:
794 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
796 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
799 case OVERLAY_ARROW_BITMAP
:
803 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
805 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
808 case RIGHT_TRUNCATION_BITMAP
:
812 x
= window_box_right (w
, -1);
813 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
816 case CONTINUED_LINE_BITMAP
:
819 bits
= continued_bits
;
820 x
= window_box_right (w
, -1);
821 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
824 case CONTINUATION_LINE_BITMAP
:
825 wd
= continuation_width
;
826 h
= continuation_height
;
827 bits
= continuation_bits
;
828 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
830 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
837 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
839 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
846 /* Convert to frame coordinates. Set dy to the offset in the row to
847 start drawing the bitmap. */
848 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
849 dy
= (row
->height
- h
) / 2;
851 /* Draw the bitmap. I believe these small pixmaps can be cached
853 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
854 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, wd
, h
,
856 face
->background
, depth
);
857 XCopyArea (display
, pixmap
, window
, gc
, 0, 0, wd
, h
, x
, y
+ dy
);
858 XFreePixmap (display
, pixmap
);
859 XSetClipMask (display
, gc
, None
);
863 /* Draw flags bitmaps for glyph row ROW on window W. Call this
864 function with input blocked. */
867 x_draw_row_bitmaps (w
, row
)
869 struct glyph_row
*row
;
871 struct frame
*f
= XFRAME (w
->frame
);
872 enum bitmap_type bitmap
;
874 int header_line_height
= -1;
876 xassert (interrupt_input_blocked
);
878 /* If row is completely invisible, because of vscrolling, we
879 don't have to draw anything. */
880 if (row
->visible_height
<= 0)
883 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
884 PREPARE_FACE_FOR_DISPLAY (f
, face
);
886 /* Decide which bitmap to draw at the left side. */
887 if (row
->overlay_arrow_p
)
888 bitmap
= OVERLAY_ARROW_BITMAP
;
889 else if (row
->truncated_on_left_p
)
890 bitmap
= LEFT_TRUNCATION_BITMAP
;
891 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
892 bitmap
= CONTINUATION_LINE_BITMAP
;
893 else if (row
->indicate_empty_line_p
)
894 bitmap
= ZV_LINE_BITMAP
;
898 /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
900 if (bitmap
== NO_BITMAP
901 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
902 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
904 /* If W has a vertical border to its left, don't draw over it. */
905 int border
= ((XFASTINT (w
->left
) > 0
906 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
908 int left
= window_box_left (w
, -1);
910 if (header_line_height
< 0)
911 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
913 /* In case the same realized face is used for bitmap areas and
914 for something displayed in the text (e.g. face `region' on
915 mono-displays, the fill style may have been changed to
916 FillSolid in x_draw_glyph_string_background. */
918 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
920 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
922 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
925 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
927 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
929 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - border
,
930 row
->visible_height
);
932 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
935 /* Draw the left bitmap. */
936 if (bitmap
!= NO_BITMAP
)
937 x_draw_bitmap (w
, row
, bitmap
);
939 /* Decide which bitmap to draw at the right side. */
940 if (row
->truncated_on_right_p
)
941 bitmap
= RIGHT_TRUNCATION_BITMAP
;
942 else if (row
->continued_p
)
943 bitmap
= CONTINUED_LINE_BITMAP
;
947 /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
949 if (bitmap
== NO_BITMAP
950 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
)
951 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
953 int right
= window_box_right (w
, -1);
955 if (header_line_height
< 0)
956 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
958 /* In case the same realized face is used for bitmap areas and
959 for something displayed in the text (e.g. face `region' on
960 mono-displays, the fill style may have been changed to
961 FillSolid in x_draw_glyph_string_background. */
963 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
965 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
966 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
969 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
971 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
),
972 row
->visible_height
);
974 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
977 /* Draw the right bitmap. */
978 if (bitmap
!= NO_BITMAP
)
979 x_draw_bitmap (w
, row
, bitmap
);
983 /***********************************************************************
985 ***********************************************************************/
987 /* External interface to control of standout mode. Not used for X
988 frames. Aborts when called. */
991 XTreassert_line_highlight (new, vpos
)
998 /* Call this when about to modify line at position VPOS and change
999 whether it is highlighted. Not used for X frames. Aborts when
1003 x_change_line_highlight (new_highlight
, vpos
, y
, first_unused_hpos
)
1004 int new_highlight
, vpos
, y
, first_unused_hpos
;
1010 /* This is called when starting Emacs and when restarting after
1011 suspend. When starting Emacs, no X window is mapped. And nothing
1012 must be done to Emacs's own window if it is suspended (though that
1016 XTset_terminal_modes ()
1020 /* This is called when exiting or suspending Emacs. Exiting will make
1021 the X-windows go away, and suspending requires no action. */
1024 XTreset_terminal_modes ()
1030 /***********************************************************************
1032 ***********************************************************************/
1034 /* Set the global variable output_cursor to CURSOR. All cursor
1035 positions are relative to updated_window. */
1038 set_output_cursor (cursor
)
1039 struct cursor_pos
*cursor
;
1041 output_cursor
.hpos
= cursor
->hpos
;
1042 output_cursor
.vpos
= cursor
->vpos
;
1043 output_cursor
.x
= cursor
->x
;
1044 output_cursor
.y
= cursor
->y
;
1048 /* Set a nominal cursor position.
1050 HPOS and VPOS are column/row positions in a window glyph matrix. X
1051 and Y are window text area relative pixel positions.
1053 If this is done during an update, updated_window will contain the
1054 window that is being updated and the position is the future output
1055 cursor position for that window. If updated_window is null, use
1056 selected_window and display the cursor at the given position. */
1059 XTcursor_to (vpos
, hpos
, y
, x
)
1060 int vpos
, hpos
, y
, x
;
1064 /* If updated_window is not set, work on selected_window. */
1068 w
= XWINDOW (selected_window
);
1070 /* Set the output cursor. */
1071 output_cursor
.hpos
= hpos
;
1072 output_cursor
.vpos
= vpos
;
1073 output_cursor
.x
= x
;
1074 output_cursor
.y
= y
;
1076 /* If not called as part of an update, really display the cursor.
1077 This will also set the cursor position of W. */
1078 if (updated_window
== NULL
)
1081 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1082 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1089 /***********************************************************************
1091 ***********************************************************************/
1093 /* Function prototypes of this page. */
1095 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1099 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1100 int, XChar2b
*, int));
1101 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
1102 static void x_encode_char
P_ ((int, XChar2b
*, struct font_info
*));
1103 static void x_append_glyph
P_ ((struct it
*));
1104 static void x_append_composite_glyph
P_ ((struct it
*));
1105 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1107 static void x_produce_glyphs
P_ ((struct it
*));
1108 static void x_produce_image_glyph
P_ ((struct it
*it
));
1111 /* Return a pointer to per-char metric information in FONT of a
1112 character pointed by B which is a pointer to an XChar2b. */
1114 #define PER_CHAR_METRIC(font, b) \
1116 ? ((font)->per_char + (b)->byte2 - (font)->min_char_or_byte2 \
1117 + (((font)->min_byte1 || (font)->max_byte1) \
1118 ? (((b)->byte1 - (font)->min_byte1) \
1119 * ((font)->max_char_or_byte2 - (font)->min_char_or_byte2 + 1)) \
1121 : &((font)->max_bounds))
1124 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1125 is not contained in the font. */
1127 static INLINE XCharStruct
*
1128 x_per_char_metric (font
, char2b
)
1132 /* The result metric information. */
1133 XCharStruct
*pcm
= NULL
;
1135 xassert (font
&& char2b
);
1137 if (font
->per_char
!= NULL
)
1139 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
1141 /* min_char_or_byte2 specifies the linear character index
1142 corresponding to the first element of the per_char array,
1143 max_char_or_byte2 is the index of the last character. A
1144 character with non-zero CHAR2B->byte1 is not in the font.
1145 A character with byte2 less than min_char_or_byte2 or
1146 greater max_char_or_byte2 is not in the font. */
1147 if (char2b
->byte1
== 0
1148 && char2b
->byte2
>= font
->min_char_or_byte2
1149 && char2b
->byte2
<= font
->max_char_or_byte2
)
1150 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
1154 /* If either min_byte1 or max_byte1 are nonzero, both
1155 min_char_or_byte2 and max_char_or_byte2 are less than
1156 256, and the 2-byte character index values corresponding
1157 to the per_char array element N (counting from 0) are:
1159 byte1 = N/D + min_byte1
1160 byte2 = N\D + min_char_or_byte2
1164 D = max_char_or_byte2 - min_char_or_byte2 + 1
1165 / = integer division
1166 \ = integer modulus */
1167 if (char2b
->byte1
>= font
->min_byte1
1168 && char2b
->byte1
<= font
->max_byte1
1169 && char2b
->byte2
>= font
->min_char_or_byte2
1170 && char2b
->byte2
<= font
->max_char_or_byte2
)
1172 pcm
= (font
->per_char
1173 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
1174 * (char2b
->byte1
- font
->min_byte1
))
1175 + (char2b
->byte2
- font
->min_char_or_byte2
));
1181 /* If the per_char pointer is null, all glyphs between the first
1182 and last character indexes inclusive have the same
1183 information, as given by both min_bounds and max_bounds. */
1184 if (char2b
->byte2
>= font
->min_char_or_byte2
1185 && char2b
->byte2
<= font
->max_char_or_byte2
)
1186 pcm
= &font
->max_bounds
;
1189 return ((pcm
== NULL
1190 || pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0)
1195 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1196 the two-byte form of C. Encoding is returned in *CHAR2B. */
1199 x_encode_char (c
, char2b
, font_info
)
1202 struct font_info
*font_info
;
1204 int charset
= CHAR_CHARSET (c
);
1205 XFontStruct
*font
= font_info
->font
;
1207 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1208 This may be either a program in a special encoder language or a
1210 if (font_info
->font_encoder
)
1212 /* It's a program. */
1213 struct ccl_program
*ccl
= font_info
->font_encoder
;
1215 if (CHARSET_DIMENSION (charset
) == 1)
1217 ccl
->reg
[0] = charset
;
1218 ccl
->reg
[1] = char2b
->byte2
;
1222 ccl
->reg
[0] = charset
;
1223 ccl
->reg
[1] = char2b
->byte1
;
1224 ccl
->reg
[2] = char2b
->byte2
;
1227 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1229 /* We assume that MSBs are appropriately set/reset by CCL
1231 if (font
->max_byte1
== 0) /* 1-byte font */
1232 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
1234 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
1236 else if (font_info
->encoding
[charset
])
1238 /* Fixed encoding scheme. See fontset.h for the meaning of the
1239 encoding numbers. */
1240 int enc
= font_info
->encoding
[charset
];
1242 if ((enc
== 1 || enc
== 2)
1243 && CHARSET_DIMENSION (charset
) == 2)
1244 char2b
->byte1
|= 0x80;
1246 if (enc
== 1 || enc
== 3)
1247 char2b
->byte2
|= 0x80;
1252 /* Get face and two-byte form of character C in face FACE_ID on frame
1253 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1254 means we want to display multibyte text. Value is a pointer to a
1255 realized face that is ready for display. */
1257 static INLINE
struct face
*
1258 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
)
1264 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1268 /* Unibyte case. We don't have to encode, but we have to make
1269 sure to use a face suitable for unibyte. */
1272 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1273 face
= FACE_FROM_ID (f
, face_id
);
1275 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1277 /* Case of ASCII in a face known to fit ASCII. */
1283 int c1
, c2
, charset
;
1285 /* Split characters into bytes. If c2 is -1 afterwards, C is
1286 really a one-byte character so that byte1 is zero. */
1287 SPLIT_CHAR (c
, charset
, c1
, c2
);
1289 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1291 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1293 /* Maybe encode the character in *CHAR2B. */
1294 if (face
->font
!= NULL
)
1296 struct font_info
*font_info
1297 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1299 x_encode_char (c
, char2b
, font_info
);
1303 /* Make sure X resources of the face are allocated. */
1304 xassert (face
!= NULL
);
1305 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1311 /* Get face and two-byte form of character glyph GLYPH on frame F.
1312 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1313 a pointer to a realized face that is ready for display. */
1315 static INLINE
struct face
*
1316 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1318 struct glyph
*glyph
;
1324 xassert (glyph
->type
== CHAR_GLYPH
);
1325 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1330 if (!glyph
->multibyte_p
)
1332 /* Unibyte case. We don't have to encode, but we have to make
1333 sure to use a face suitable for unibyte. */
1335 char2b
->byte2
= glyph
->u
.ch
;
1337 else if (glyph
->u
.ch
< 128
1338 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1340 /* Case of ASCII in a face known to fit ASCII. */
1342 char2b
->byte2
= glyph
->u
.ch
;
1346 int c1
, c2
, charset
;
1348 /* Split characters into bytes. If c2 is -1 afterwards, C is
1349 really a one-byte character so that byte1 is zero. */
1350 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1352 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1354 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1356 /* Maybe encode the character in *CHAR2B. */
1357 if (charset
!= CHARSET_ASCII
)
1359 struct font_info
*font_info
1360 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1363 x_encode_char (glyph
->u
.ch
, char2b
, font_info
);
1366 = ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
1371 /* Make sure X resources of the face are allocated. */
1372 xassert (face
!= NULL
);
1373 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1378 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1379 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1385 struct glyph
*glyph
;
1386 enum glyph_row_area area
= it
->area
;
1388 xassert (it
->glyph_row
);
1389 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1391 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1392 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1394 /* Play it safe. If sub-structures of the glyph are not all the
1395 same size, it otherwise be that some bits stay set. This
1396 would prevent a comparison with GLYPH_EQUAL_P. */
1399 glyph
->type
= CHAR_GLYPH
;
1400 glyph
->pixel_width
= it
->pixel_width
;
1401 glyph
->u
.ch
= it
->char_to_display
;
1402 glyph
->face_id
= it
->face_id
;
1403 glyph
->charpos
= CHARPOS (it
->position
);
1404 glyph
->object
= it
->object
;
1405 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1406 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1407 glyph
->voffset
= it
->voffset
;
1408 glyph
->multibyte_p
= it
->multibyte_p
;
1409 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1410 || it
->phys_descent
> it
->descent
);
1411 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1412 ++it
->glyph_row
->used
[area
];
1416 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1417 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1420 x_append_composite_glyph (it
)
1423 struct glyph
*glyph
;
1424 enum glyph_row_area area
= it
->area
;
1426 xassert (it
->glyph_row
);
1428 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1429 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1431 /* Play it safe. If sub-structures of the glyph are not all the
1432 same size, it otherwise be that some bits stay set. This
1433 would prevent a comparison with GLYPH_EQUAL_P. */
1436 glyph
->type
= COMPOSITE_GLYPH
;
1437 glyph
->pixel_width
= it
->pixel_width
;
1438 glyph
->u
.cmp_id
= it
->cmp_id
;
1439 glyph
->face_id
= it
->face_id
;
1440 glyph
->charpos
= CHARPOS (it
->position
);
1441 glyph
->object
= it
->object
;
1442 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1443 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1444 glyph
->voffset
= it
->voffset
;
1445 glyph
->multibyte_p
= it
->multibyte_p
;
1446 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1447 || it
->phys_descent
> it
->descent
);
1448 ++it
->glyph_row
->used
[area
];
1453 /* Change IT->ascent and IT->height according to the setting of
1457 take_vertical_position_into_account (it
)
1462 if (it
->voffset
< 0)
1463 /* Increase the ascent so that we can display the text higher
1465 it
->ascent
+= abs (it
->voffset
);
1467 /* Increase the descent so that we can display the text lower
1469 it
->descent
+= it
->voffset
;
1474 /* Produce glyphs/get display metrics for the image IT is loaded with.
1475 See the description of struct display_iterator in dispextern.h for
1476 an overview of struct display_iterator. */
1479 x_produce_image_glyph (it
)
1485 xassert (it
->what
== IT_IMAGE
);
1487 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1488 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1491 /* Make sure X resources of the face and image are loaded. */
1492 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1493 prepare_image_for_display (it
->f
, img
);
1495 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1496 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->margin
- it
->ascent
;
1497 it
->pixel_width
= img
->width
+ 2 * img
->margin
;
1501 if (face
->box
!= FACE_NO_BOX
)
1503 it
->ascent
+= face
->box_line_width
;
1504 it
->descent
+= face
->box_line_width
;
1506 if (it
->start_of_box_run_p
)
1507 it
->pixel_width
+= face
->box_line_width
;
1508 if (it
->end_of_box_run_p
)
1509 it
->pixel_width
+= face
->box_line_width
;
1512 take_vertical_position_into_account (it
);
1516 struct glyph
*glyph
;
1517 enum glyph_row_area area
= it
->area
;
1519 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1520 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1522 glyph
->type
= IMAGE_GLYPH
;
1523 glyph
->u
.img_id
= img
->id
;
1524 glyph
->face_id
= it
->face_id
;
1525 glyph
->pixel_width
= it
->pixel_width
;
1526 glyph
->charpos
= CHARPOS (it
->position
);
1527 glyph
->object
= it
->object
;
1528 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1529 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1530 glyph
->voffset
= it
->voffset
;
1531 glyph
->multibyte_p
= it
->multibyte_p
;
1532 ++it
->glyph_row
->used
[area
];
1538 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1539 of the glyph, WIDTH and HEIGHT are the width and height of the
1540 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1541 ascent of the glyph (0 <= ASCENT <= 1). */
1544 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1550 struct glyph
*glyph
;
1551 enum glyph_row_area area
= it
->area
;
1553 xassert (ascent
>= 0 && ascent
<= 1);
1555 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1556 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1558 glyph
->type
= STRETCH_GLYPH
;
1559 glyph
->u
.stretch
.ascent
= height
* ascent
;
1560 glyph
->u
.stretch
.height
= height
;
1561 glyph
->face_id
= it
->face_id
;
1562 glyph
->pixel_width
= width
;
1563 glyph
->charpos
= CHARPOS (it
->position
);
1564 glyph
->object
= object
;
1565 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1566 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1567 glyph
->voffset
= it
->voffset
;
1568 glyph
->multibyte_p
= it
->multibyte_p
;
1569 ++it
->glyph_row
->used
[area
];
1574 /* Produce a stretch glyph for iterator IT. IT->object is the value
1575 of the glyph property displayed. The value must be a list
1576 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1579 1. `:width WIDTH' specifies that the space should be WIDTH *
1580 canonical char width wide. WIDTH may be an integer or floating
1583 2. `:relative-width FACTOR' specifies that the width of the stretch
1584 should be computed from the width of the first character having the
1585 `glyph' property, and should be FACTOR times that width.
1587 3. `:align-to HPOS' specifies that the space should be wide enough
1588 to reach HPOS, a value in canonical character units.
1590 Exactly one of the above pairs must be present.
1592 4. `:height HEIGHT' specifies that the height of the stretch produced
1593 should be HEIGHT, measured in canonical character units.
1595 5. `:relative-height FACTOR' specifies that the height of the the
1596 stretch should be FACTOR times the height of the characters having
1599 Either none or exactly one of 4 or 5 must be present.
1601 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1602 of the stretch should be used for the ascent of the stretch.
1603 ASCENT must be in the range 0 <= ASCENT <= 100. */
1606 ((INTEGERP (X) || FLOATP (X)) \
1612 x_produce_stretch_glyph (it
)
1615 /* (space :width WIDTH :height HEIGHT. */
1616 extern Lisp_Object QCwidth
, QCheight
, QCascent
, Qspace
;
1617 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1618 extern Lisp_Object QCalign_to
;
1619 Lisp_Object prop
, plist
;
1620 double width
= 0, height
= 0, ascent
= 0;
1621 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1622 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1624 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1626 /* List should start with `space'. */
1627 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1628 plist
= XCDR (it
->object
);
1630 /* Compute the width of the stretch. */
1631 if (prop
= Fplist_get (plist
, QCwidth
),
1633 /* Absolute width `:width WIDTH' specified and valid. */
1634 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1635 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1638 /* Relative width `:relative-width FACTOR' specified and valid.
1639 Compute the width of the characters having the `glyph'
1642 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1645 if (it
->multibyte_p
)
1647 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1648 - IT_BYTEPOS (*it
));
1649 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1652 it2
.c
= *p
, it2
.len
= 1;
1654 it2
.glyph_row
= NULL
;
1655 it2
.what
= IT_CHARACTER
;
1656 x_produce_glyphs (&it2
);
1657 width
= NUMVAL (prop
) * it2
.pixel_width
;
1659 else if (prop
= Fplist_get (plist
, QCalign_to
),
1661 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1663 /* Nothing specified -> width defaults to canonical char width. */
1664 width
= CANON_X_UNIT (it
->f
);
1666 /* Compute height. */
1667 if (prop
= Fplist_get (plist
, QCheight
),
1669 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1670 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1672 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1674 height
= FONT_HEIGHT (font
);
1676 /* Compute percentage of height used for ascent. If
1677 `:ascent ASCENT' is present and valid, use that. Otherwise,
1678 derive the ascent from the font in use. */
1679 if (prop
= Fplist_get (plist
, QCascent
),
1680 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1681 ascent
= NUMVAL (prop
) / 100.0;
1683 ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1692 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1693 if (!STRINGP (object
))
1694 object
= it
->w
->buffer
;
1695 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1698 it
->pixel_width
= width
;
1699 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1700 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1703 if (face
->box
!= FACE_NO_BOX
)
1705 it
->ascent
+= face
->box_line_width
;
1706 it
->descent
+= face
->box_line_width
;
1708 if (it
->start_of_box_run_p
)
1709 it
->pixel_width
+= face
->box_line_width
;
1710 if (it
->end_of_box_run_p
)
1711 it
->pixel_width
+= face
->box_line_width
;
1714 take_vertical_position_into_account (it
);
1717 /* Return proper value to be used as baseline offset of font that has
1718 ASCENT and DESCENT to draw characters by the font at the vertical
1719 center of the line of frame F.
1721 Here, out task is to find the value of BOFF in the following figure;
1723 -------------------------+-----------+-
1724 -+-+---------+-+ | |
1726 | | | | F_ASCENT F_HEIGHT
1729 | | |-|-+------+-----------|------- baseline
1731 | |---------|-+-+ | |
1733 -+-+---------+-+ F_DESCENT |
1734 -------------------------+-----------+-
1736 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1737 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1738 DESCENT = FONT->descent
1739 HEIGHT = FONT_HEIGHT (FONT)
1740 F_DESCENT = (F->output_data.x->font->descent
1741 - F->output_data.x->baseline_offset)
1742 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1745 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1747 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT))) / 2 \
1748 - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
1750 /* Produce glyphs/get display metrics for the display element IT is
1751 loaded with. See the description of struct display_iterator in
1752 dispextern.h for an overview of struct display_iterator. */
1755 x_produce_glyphs (it
)
1758 it
->glyph_not_available_p
= 0;
1760 if (it
->what
== IT_CHARACTER
)
1764 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1766 int font_not_found_p
;
1767 struct font_info
*font_info
;
1768 int boff
; /* baseline offset */
1770 /* Maybe translate single-byte characters to multibyte, or the
1772 it
->char_to_display
= it
->c
;
1773 if (!ASCII_BYTE_P (it
->c
))
1775 if (unibyte_display_via_language_environment
1776 && SINGLE_BYTE_CHAR_P (it
->c
)
1778 || !NILP (Vnonascii_translation_table
)))
1780 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
1781 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1782 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1784 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
1785 && !it
->multibyte_p
)
1787 it
->char_to_display
= multibyte_char_to_unibyte (it
->c
, Qnil
);
1788 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1789 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1793 /* Get font to use. Encode IT->char_to_display. */
1794 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
1795 it
->face_id
, &char2b
,
1799 /* When no suitable font found, use the default font. */
1800 font_not_found_p
= font
== NULL
;
1801 if (font_not_found_p
)
1803 font
= FRAME_FONT (it
->f
);
1804 boff
= it
->f
->output_data
.x
->baseline_offset
;
1809 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
1810 boff
= font_info
->baseline_offset
;
1811 if (font_info
->vertical_centering
)
1812 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
1815 if (it
->char_to_display
>= ' '
1816 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
1818 /* Either unibyte or ASCII. */
1823 pcm
= x_per_char_metric (font
, &char2b
);
1824 it
->ascent
= font
->ascent
+ boff
;
1825 it
->descent
= font
->descent
- boff
;
1829 it
->phys_ascent
= pcm
->ascent
+ boff
;
1830 it
->phys_descent
= pcm
->descent
- boff
;
1831 it
->pixel_width
= pcm
->width
;
1835 it
->glyph_not_available_p
= 1;
1836 it
->phys_ascent
= font
->ascent
+ boff
;
1837 it
->phys_descent
= font
->descent
- boff
;
1838 it
->pixel_width
= FONT_WIDTH (font
);
1841 /* If this is a space inside a region of text with
1842 `space-width' property, change its width. */
1843 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
1845 it
->pixel_width
*= XFLOATINT (it
->space_width
);
1847 /* If face has a box, add the box thickness to the character
1848 height. If character has a box line to the left and/or
1849 right, add the box line width to the character's width. */
1850 if (face
->box
!= FACE_NO_BOX
)
1852 int thick
= face
->box_line_width
;
1854 it
->ascent
+= thick
;
1855 it
->descent
+= thick
;
1857 if (it
->start_of_box_run_p
)
1858 it
->pixel_width
+= thick
;
1859 if (it
->end_of_box_run_p
)
1860 it
->pixel_width
+= thick
;
1863 /* If face has an overline, add the height of the overline
1864 (1 pixel) and a 1 pixel margin to the character height. */
1865 if (face
->overline_p
)
1868 take_vertical_position_into_account (it
);
1870 /* If we have to actually produce glyphs, do it. */
1875 /* Translate a space with a `space-width' property
1876 into a stretch glyph. */
1877 double ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1878 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1879 it
->ascent
+ it
->descent
, ascent
);
1882 x_append_glyph (it
);
1884 /* If characters with lbearing or rbearing are displayed
1885 in this line, record that fact in a flag of the
1886 glyph row. This is used to optimize X output code. */
1887 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
1888 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1891 else if (it
->char_to_display
== '\n')
1893 /* A newline has no width but we need the height of the line. */
1894 it
->pixel_width
= 0;
1896 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1897 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1899 if (face
->box
!= FACE_NO_BOX
)
1901 int thick
= face
->box_line_width
;
1902 it
->ascent
+= thick
;
1903 it
->descent
+= thick
;
1906 else if (it
->char_to_display
== '\t')
1908 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
1909 int x
= it
->current_x
+ it
->continuation_lines_width
;
1910 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
1912 it
->pixel_width
= next_tab_x
- x
;
1914 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1915 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1919 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
1920 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1921 it
->ascent
+ it
->descent
, ascent
);
1926 /* A multi-byte character. Assume that the display width of the
1927 character is the width of the character multiplied by the
1928 width of the font. */
1930 /* If we found a font, this font should give us the right
1931 metrics. If we didn't find a font, use the frame's
1932 default font and calculate the width of the character
1933 from the charset width; this is what old redisplay code
1935 pcm
= x_per_char_metric (font
, &char2b
);
1936 if (font_not_found_p
|| !pcm
)
1938 int charset
= CHAR_CHARSET (it
->char_to_display
);
1940 it
->glyph_not_available_p
= 1;
1941 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
1942 * CHARSET_WIDTH (charset
));
1943 it
->phys_ascent
= font
->ascent
+ boff
;
1944 it
->phys_descent
= font
->descent
- boff
;
1948 it
->pixel_width
= pcm
->width
;
1949 it
->phys_ascent
= pcm
->ascent
+ boff
;
1950 it
->phys_descent
= pcm
->descent
- boff
;
1952 && (pcm
->lbearing
< 0
1953 || pcm
->rbearing
> pcm
->width
))
1954 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1957 it
->ascent
= font
->ascent
+ boff
;
1958 it
->descent
= font
->descent
- boff
;
1959 if (face
->box
!= FACE_NO_BOX
)
1961 int thick
= face
->box_line_width
;
1962 it
->ascent
+= thick
;
1963 it
->descent
+= thick
;
1965 if (it
->start_of_box_run_p
)
1966 it
->pixel_width
+= thick
;
1967 if (it
->end_of_box_run_p
)
1968 it
->pixel_width
+= thick
;
1971 /* If face has an overline, add the height of the overline
1972 (1 pixel) and a 1 pixel margin to the character height. */
1973 if (face
->overline_p
)
1976 take_vertical_position_into_account (it
);
1979 x_append_glyph (it
);
1982 else if (it
->what
== IT_COMPOSITION
)
1984 /* Note: A composition is represented as one glyph in the
1985 glyph matrix. There are no padding glyphs. */
1988 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1990 int font_not_found_p
;
1991 struct font_info
*font_info
;
1992 int boff
; /* baseline offset */
1993 struct composition
*cmp
= composition_table
[it
->cmp_id
];
1995 /* Maybe translate single-byte characters to multibyte. */
1996 it
->char_to_display
= it
->c
;
1997 if (unibyte_display_via_language_environment
1998 && SINGLE_BYTE_CHAR_P (it
->c
)
2001 && !NILP (Vnonascii_translation_table
))))
2003 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2006 /* Get face and font to use. Encode IT->char_to_display. */
2007 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2008 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2009 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2010 it
->face_id
, &char2b
, it
->multibyte_p
);
2013 /* When no suitable font found, use the default font. */
2014 font_not_found_p
= font
== NULL
;
2015 if (font_not_found_p
)
2017 font
= FRAME_FONT (it
->f
);
2018 boff
= it
->f
->output_data
.x
->baseline_offset
;
2023 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2024 boff
= font_info
->baseline_offset
;
2025 if (font_info
->vertical_centering
)
2026 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2029 /* There are no padding glyphs, so there is only one glyph to
2030 produce for the composition. Important is that pixel_width,
2031 ascent and descent are the values of what is drawn by
2032 draw_glyphs (i.e. the values of the overall glyphs composed). */
2035 /* If we have not yet calculated pixel size data of glyphs of
2036 the composition for the current face font, calculate them
2037 now. Theoretically, we have to check all fonts for the
2038 glyphs, but that requires much time and memory space. So,
2039 here we check only the font of the first glyph. This leads
2040 to incorrect display very rarely, and C-l (recenter) can
2041 correct the display anyway. */
2042 if (cmp
->font
!= (void *) font
)
2044 /* Ascent and descent of the font of the first character of
2045 this composition (adjusted by baseline offset). Ascent
2046 and descent of overall glyphs should not be less than
2047 them respectively. */
2048 int font_ascent
= font
->ascent
+ boff
;
2049 int font_descent
= font
->descent
- boff
;
2050 /* Bounding box of the overall glyphs. */
2051 int leftmost
, rightmost
, lowest
, highest
;
2052 int i
, width
, ascent
, descent
;
2054 cmp
->font
= (void *) font
;
2056 /* Initialize the bounding box. */
2057 pcm
= x_per_char_metric (font
, &char2b
);
2061 ascent
= pcm
->ascent
;
2062 descent
= pcm
->descent
;
2066 width
= FONT_WIDTH (font
);
2067 ascent
= font
->ascent
;
2068 descent
= font
->descent
;
2072 lowest
= - descent
+ boff
;
2073 highest
= ascent
+ boff
;
2077 && font_info
->default_ascent
2078 && CHAR_TABLE_P (Vuse_default_ascent
)
2079 && !NILP (Faref (Vuse_default_ascent
,
2080 make_number (it
->char_to_display
))))
2081 highest
= font_info
->default_ascent
+ boff
;
2083 /* Draw the first glyph at the normal position. It may be
2084 shifted to right later if some other glyphs are drawn at
2086 cmp
->offsets
[0] = 0;
2087 cmp
->offsets
[1] = boff
;
2089 /* Set cmp->offsets for the remaining glyphs. */
2090 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2092 int left
, right
, btm
, top
;
2093 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2094 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2096 face
= FACE_FROM_ID (it
->f
, face_id
);
2097 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2102 font
= FRAME_FONT (it
->f
);
2103 boff
= it
->f
->output_data
.x
->baseline_offset
;
2109 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2110 boff
= font_info
->baseline_offset
;
2111 if (font_info
->vertical_centering
)
2112 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2115 pcm
= x_per_char_metric (font
, &char2b
);
2119 ascent
= pcm
->ascent
;
2120 descent
= pcm
->descent
;
2124 width
= FONT_WIDTH (font
);
2125 ascent
= font
->ascent
;
2126 descent
= font
->descent
;
2129 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2131 /* Relative composition with or without
2133 left
= (leftmost
+ rightmost
- width
) / 2;
2134 btm
= - descent
+ boff
;
2135 if (font_info
&& font_info
->relative_compose
2136 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2137 || NILP (Faref (Vignore_relative_composition
,
2138 make_number (ch
)))))
2141 if (- descent
>= font_info
->relative_compose
)
2142 /* One extra pixel between two glyphs. */
2144 else if (ascent
<= 0)
2145 /* One extra pixel between two glyphs. */
2146 btm
= lowest
- 1 - ascent
- descent
;
2151 /* A composition rule is specified by an integer
2152 value that encodes global and new reference
2153 points (GREF and NREF). GREF and NREF are
2154 specified by numbers as below:
2162 ---3---4---5--- baseline
2164 6---7---8 -- descent
2166 int rule
= COMPOSITION_RULE (cmp
, i
);
2167 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2169 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2170 grefx
= gref
% 3, nrefx
= nref
% 3;
2171 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2174 + grefx
* (rightmost
- leftmost
) / 2
2175 - nrefx
* width
/ 2);
2176 btm
= ((grefy
== 0 ? highest
2178 : grefy
== 2 ? lowest
2179 : (highest
+ lowest
) / 2)
2180 - (nrefy
== 0 ? ascent
+ descent
2181 : nrefy
== 1 ? descent
- boff
2183 : (ascent
+ descent
) / 2));
2186 cmp
->offsets
[i
* 2] = left
;
2187 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2189 /* Update the bounding box of the overall glyphs. */
2190 right
= left
+ width
;
2191 top
= btm
+ descent
+ ascent
;
2192 if (left
< leftmost
)
2194 if (right
> rightmost
)
2202 /* If there are glyphs whose x-offsets are negative,
2203 shift all glyphs to the right and make all x-offsets
2207 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2208 cmp
->offsets
[i
* 2] -= leftmost
;
2209 rightmost
-= leftmost
;
2212 cmp
->pixel_width
= rightmost
;
2213 cmp
->ascent
= highest
;
2214 cmp
->descent
= - lowest
;
2215 if (cmp
->ascent
< font_ascent
)
2216 cmp
->ascent
= font_ascent
;
2217 if (cmp
->descent
< font_descent
)
2218 cmp
->descent
= font_descent
;
2221 it
->pixel_width
= cmp
->pixel_width
;
2222 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2223 it
->descent
= it
->phys_descent
= cmp
->descent
;
2225 if (face
->box
!= FACE_NO_BOX
)
2227 int thick
= face
->box_line_width
;
2228 it
->ascent
+= thick
;
2229 it
->descent
+= thick
;
2231 if (it
->start_of_box_run_p
)
2232 it
->pixel_width
+= thick
;
2233 if (it
->end_of_box_run_p
)
2234 it
->pixel_width
+= thick
;
2237 /* If face has an overline, add the height of the overline
2238 (1 pixel) and a 1 pixel margin to the character height. */
2239 if (face
->overline_p
)
2242 take_vertical_position_into_account (it
);
2245 x_append_composite_glyph (it
);
2247 else if (it
->what
== IT_IMAGE
)
2248 x_produce_image_glyph (it
);
2249 else if (it
->what
== IT_STRETCH
)
2250 x_produce_stretch_glyph (it
);
2252 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2253 because this isn't true for images with `:ascent 100'. */
2254 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2255 if (it
->area
== TEXT_AREA
)
2256 it
->current_x
+= it
->pixel_width
;
2258 it
->descent
+= it
->extra_line_spacing
;
2260 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2261 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2262 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2263 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2267 /* Estimate the pixel height of the mode or top line on frame F.
2268 FACE_ID specifies what line's height to estimate. */
2271 x_estimate_mode_line_height (f
, face_id
)
2273 enum face_id face_id
;
2277 /* This function is called so early when Emacs starts that the face
2278 cache and mode line face are not yet initialized. */
2279 if (FRAME_FACE_CACHE (f
))
2281 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2283 height
= FONT_HEIGHT (face
->font
) + 2 * face
->box_line_width
;
2290 /***********************************************************************
2292 ***********************************************************************/
2294 /* A sequence of glyphs to be drawn in the same face.
2296 This data structure is not really completely X specific, so it
2297 could possibly, at least partially, be useful for other systems. It
2298 is currently not part of the external redisplay interface because
2299 it's not clear what other systems will need. */
2303 /* X-origin of the string. */
2306 /* Y-origin and y-position of the base line of this string. */
2309 /* The width of the string, not including a face extension. */
2312 /* The width of the string, including a face extension. */
2313 int background_width
;
2315 /* The height of this string. This is the height of the line this
2316 string is drawn in, and can be different from the height of the
2317 font the string is drawn in. */
2320 /* Number of pixels this string overwrites in front of its x-origin.
2321 This number is zero if the string has an lbearing >= 0; it is
2322 -lbearing, if the string has an lbearing < 0. */
2325 /* Number of pixels this string overwrites past its right-most
2326 nominal x-position, i.e. x + width. Zero if the string's
2327 rbearing is <= its nominal width, rbearing - width otherwise. */
2330 /* The frame on which the glyph string is drawn. */
2333 /* The window on which the glyph string is drawn. */
2336 /* X display and window for convenience. */
2340 /* The glyph row for which this string was built. It determines the
2341 y-origin and height of the string. */
2342 struct glyph_row
*row
;
2344 /* The area within row. */
2345 enum glyph_row_area area
;
2347 /* Characters to be drawn, and number of characters. */
2351 /* A face-override for drawing cursors, mouse face and similar. */
2352 enum draw_glyphs_face hl
;
2354 /* Face in which this string is to be drawn. */
2357 /* Font in which this string is to be drawn. */
2360 /* Font info for this string. */
2361 struct font_info
*font_info
;
2363 /* Non-null means this string describes (part of) a composition.
2364 All characters from char2b are drawn composed. */
2365 struct composition
*cmp
;
2367 /* Index of this glyph string's first character in the glyph
2368 definition of CMP. If this is zero, this glyph string describes
2369 the first character of a composition. */
2372 /* 1 means this glyph strings face has to be drawn to the right end
2373 of the window's drawing area. */
2374 unsigned extends_to_end_of_line_p
: 1;
2376 /* 1 means the background of this string has been drawn. */
2377 unsigned background_filled_p
: 1;
2379 /* 1 means glyph string must be drawn with 16-bit functions. */
2380 unsigned two_byte_p
: 1;
2382 /* 1 means that the original font determined for drawing this glyph
2383 string could not be loaded. The member `font' has been set to
2384 the frame's default font in this case. */
2385 unsigned font_not_found_p
: 1;
2387 /* 1 means that the face in which this glyph string is drawn has a
2389 unsigned stippled_p
: 1;
2391 /* 1 means only the foreground of this glyph string must be drawn,
2392 and we should use the physical height of the line this glyph
2393 string appears in as clip rect. */
2394 unsigned for_overlaps_p
: 1;
2396 /* The GC to use for drawing this glyph string. */
2399 /* A pointer to the first glyph in the string. This glyph
2400 corresponds to char2b[0]. Needed to draw rectangles if
2401 font_not_found_p is 1. */
2402 struct glyph
*first_glyph
;
2404 /* Image, if any. */
2407 struct glyph_string
*next
, *prev
;
2414 x_dump_glyph_string (s
)
2415 struct glyph_string
*s
;
2417 fprintf (stderr
, "glyph string\n");
2418 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2419 s
->x
, s
->y
, s
->width
, s
->height
);
2420 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2421 fprintf (stderr
, " hl = %d\n", s
->hl
);
2422 fprintf (stderr
, " left overhang = %d, right = %d\n",
2423 s
->left_overhang
, s
->right_overhang
);
2424 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2425 fprintf (stderr
, " extends to end of line = %d\n",
2426 s
->extends_to_end_of_line_p
);
2427 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2428 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2431 #endif /* GLYPH_DEBUG */
2435 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2436 struct glyph_string
**,
2437 struct glyph_string
*,
2438 struct glyph_string
*));
2439 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2440 struct glyph_string
**,
2441 struct glyph_string
*,
2442 struct glyph_string
*));
2443 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2444 struct glyph_string
**,
2445 struct glyph_string
*));
2446 static int x_left_overwritten
P_ ((struct glyph_string
*));
2447 static int x_left_overwriting
P_ ((struct glyph_string
*));
2448 static int x_right_overwritten
P_ ((struct glyph_string
*));
2449 static int x_right_overwriting
P_ ((struct glyph_string
*));
2450 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2452 static void x_init_glyph_string
P_ ((struct glyph_string
*,
2453 XChar2b
*, struct window
*,
2455 enum glyph_row_area
, int,
2456 enum draw_glyphs_face
));
2457 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2458 enum glyph_row_area
, int, int,
2459 enum draw_glyphs_face
, int *, int *, int));
2460 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2461 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2462 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2464 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2465 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2466 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2467 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2468 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2469 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2470 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2471 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2472 static void x_get_glyph_overhangs
P_ ((struct glyph
*, struct frame
*,
2474 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2475 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
2476 unsigned long *, double, int));
2477 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2478 double, int, unsigned long));
2479 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2480 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2481 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2482 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2483 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
2484 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2485 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2487 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2488 int, int, int, int, XRectangle
*));
2489 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2490 int, int, int, XRectangle
*));
2491 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2492 enum glyph_row_area
));
2495 /* Append the list of glyph strings with head H and tail T to the list
2496 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2499 x_append_glyph_string_lists (head
, tail
, h
, t
)
2500 struct glyph_string
**head
, **tail
;
2501 struct glyph_string
*h
, *t
;
2515 /* Prepend the list of glyph strings with head H and tail T to the
2516 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2520 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2521 struct glyph_string
**head
, **tail
;
2522 struct glyph_string
*h
, *t
;
2536 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2537 Set *HEAD and *TAIL to the resulting list. */
2540 x_append_glyph_string (head
, tail
, s
)
2541 struct glyph_string
**head
, **tail
;
2542 struct glyph_string
*s
;
2544 s
->next
= s
->prev
= NULL
;
2545 x_append_glyph_string_lists (head
, tail
, s
, s
);
2549 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2554 struct glyph_string
*s
;
2556 if (s
->font
== FRAME_FONT (s
->f
)
2557 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2558 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2560 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
2563 /* Cursor on non-default face: must merge. */
2567 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
2568 xgcv
.foreground
= s
->face
->background
;
2570 /* If the glyph would be invisible, try a different foreground. */
2571 if (xgcv
.foreground
== xgcv
.background
)
2572 xgcv
.foreground
= s
->face
->foreground
;
2573 if (xgcv
.foreground
== xgcv
.background
)
2574 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
2575 if (xgcv
.foreground
== xgcv
.background
)
2576 xgcv
.foreground
= s
->face
->foreground
;
2578 /* Make sure the cursor is distinct from text in this face. */
2579 if (xgcv
.background
== s
->face
->background
2580 && xgcv
.foreground
== s
->face
->foreground
)
2582 xgcv
.background
= s
->face
->foreground
;
2583 xgcv
.foreground
= s
->face
->background
;
2586 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2587 xgcv
.font
= s
->font
->fid
;
2588 xgcv
.graphics_exposures
= False
;
2589 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2591 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2592 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2595 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2596 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2598 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2603 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2606 x_set_mouse_face_gc (s
)
2607 struct glyph_string
*s
;
2612 /* What face has to be used for the mouse face? */
2613 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2614 face
= FACE_FROM_ID (s
->f
, face_id
);
2615 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2616 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2618 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2619 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2620 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2622 /* If font in this face is same as S->font, use it. */
2623 if (s
->font
== s
->face
->font
)
2624 s
->gc
= s
->face
->gc
;
2627 /* Otherwise construct scratch_cursor_gc with values from FACE
2632 xgcv
.background
= s
->face
->background
;
2633 xgcv
.foreground
= s
->face
->foreground
;
2634 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2635 xgcv
.font
= s
->font
->fid
;
2636 xgcv
.graphics_exposures
= False
;
2637 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2639 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2640 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2643 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2644 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2646 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2649 xassert (s
->gc
!= 0);
2653 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2654 Faces to use in the mode line have already been computed when the
2655 matrix was built, so there isn't much to do, here. */
2658 x_set_mode_line_face_gc (s
)
2659 struct glyph_string
*s
;
2661 s
->gc
= s
->face
->gc
;
2662 xassert (s
->gc
!= 0);
2666 /* Set S->gc of glyph string S for drawing that glyph string. Set
2667 S->stippled_p to a non-zero value if the face of S has a stipple
2671 x_set_glyph_string_gc (s
)
2672 struct glyph_string
*s
;
2674 if (s
->hl
== DRAW_NORMAL_TEXT
)
2676 s
->gc
= s
->face
->gc
;
2677 s
->stippled_p
= s
->face
->stipple
!= 0;
2679 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2681 x_set_mode_line_face_gc (s
);
2682 s
->stippled_p
= s
->face
->stipple
!= 0;
2684 else if (s
->hl
== DRAW_CURSOR
)
2686 x_set_cursor_gc (s
);
2689 else if (s
->hl
== DRAW_MOUSE_FACE
)
2691 x_set_mouse_face_gc (s
);
2692 s
->stippled_p
= s
->face
->stipple
!= 0;
2694 else if (s
->hl
== DRAW_IMAGE_RAISED
2695 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2697 s
->gc
= s
->face
->gc
;
2698 s
->stippled_p
= s
->face
->stipple
!= 0;
2702 s
->gc
= s
->face
->gc
;
2703 s
->stippled_p
= s
->face
->stipple
!= 0;
2706 /* GC must have been set. */
2707 xassert (s
->gc
!= 0);
2711 /* Return in *R the clipping rectangle for glyph string S. */
2714 x_get_glyph_string_clip_rect (s
, r
)
2715 struct glyph_string
*s
;
2718 if (s
->row
->full_width_p
)
2720 /* Draw full-width. X coordinates are relative to S->w->left. */
2721 int canon_x
= CANON_X_UNIT (s
->f
);
2723 r
->x
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
2724 r
->width
= XFASTINT (s
->w
->width
) * canon_x
;
2726 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
2728 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
2729 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
2733 r
->x
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
2735 /* Unless displaying a mode or menu bar line, which are always
2736 fully visible, clip to the visible part of the row. */
2737 if (s
->w
->pseudo_window_p
)
2738 r
->height
= s
->row
->visible_height
;
2740 r
->height
= s
->height
;
2744 /* This is a text line that may be partially visible. */
2745 r
->x
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
2746 r
->width
= window_box_width (s
->w
, s
->area
);
2747 r
->height
= s
->row
->visible_height
;
2750 /* Don't use S->y for clipping because it doesn't take partially
2751 visible lines into account. For example, it can be negative for
2752 partially visible lines at the top of a window. */
2753 if (!s
->row
->full_width_p
2754 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2755 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2757 r
->y
= max (0, s
->row
->y
);
2759 /* If drawing a tool-bar window, draw it over the internal border
2760 at the top of the window. */
2761 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
2762 r
->y
-= s
->f
->output_data
.x
->internal_border_width
;
2764 /* If S draws overlapping rows, it's sufficient to use the top and
2765 bottom of the window for clipping because this glyph string
2766 intentionally draws over other lines. */
2767 if (s
->for_overlaps_p
)
2769 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2770 r
->height
= window_text_bottom_y (s
->w
) - r
->y
;
2773 r
->y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->y
);
2777 /* Set clipping for output of glyph string S. S may be part of a mode
2778 line or menu if we don't have X toolkit support. */
2781 x_set_glyph_string_clipping (s
)
2782 struct glyph_string
*s
;
2785 x_get_glyph_string_clip_rect (s
, &r
);
2786 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
2790 /* Compute left and right overhang of glyph string S. If S is a glyph
2791 string for a composition, assume overhangs don't exist. */
2794 x_compute_glyph_string_overhangs (s
)
2795 struct glyph_string
*s
;
2798 && s
->first_glyph
->type
== CHAR_GLYPH
)
2801 int direction
, font_ascent
, font_descent
;
2802 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
2803 &font_ascent
, &font_descent
, &cs
);
2804 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2805 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2810 /* Compute overhangs and x-positions for glyph string S and its
2811 predecessors, or successors. X is the starting x-position for S.
2812 BACKWARD_P non-zero means process predecessors. */
2815 x_compute_overhangs_and_x (s
, x
, backward_p
)
2816 struct glyph_string
*s
;
2824 x_compute_glyph_string_overhangs (s
);
2834 x_compute_glyph_string_overhangs (s
);
2843 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2844 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2845 assumed to be zero. */
2848 x_get_glyph_overhangs (glyph
, f
, left
, right
)
2849 struct glyph
*glyph
;
2857 if (glyph
->type
== CHAR_GLYPH
)
2861 struct font_info
*font_info
;
2865 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
2867 font_info
= FONT_INFO_FROM_ID (f
, face
->font_info_id
);
2869 && (pcm
= x_per_char_metric (font
, &char2b
)))
2871 if (pcm
->rbearing
> pcm
->width
)
2872 *right
= pcm
->rbearing
- pcm
->width
;
2873 if (pcm
->lbearing
< 0)
2874 *left
= -pcm
->lbearing
;
2880 /* Return the index of the first glyph preceding glyph string S that
2881 is overwritten by S because of S's left overhang. Value is -1
2882 if no glyphs are overwritten. */
2885 x_left_overwritten (s
)
2886 struct glyph_string
*s
;
2890 if (s
->left_overhang
)
2893 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2894 int first
= s
->first_glyph
- glyphs
;
2896 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
2897 x
-= glyphs
[i
].pixel_width
;
2908 /* Return the index of the first glyph preceding glyph string S that
2909 is overwriting S because of its right overhang. Value is -1 if no
2910 glyph in front of S overwrites S. */
2913 x_left_overwriting (s
)
2914 struct glyph_string
*s
;
2917 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2918 int first
= s
->first_glyph
- glyphs
;
2922 for (i
= first
- 1; i
>= 0; --i
)
2925 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
2928 x
-= glyphs
[i
].pixel_width
;
2935 /* Return the index of the last glyph following glyph string S that is
2936 not overwritten by S because of S's right overhang. Value is -1 if
2937 no such glyph is found. */
2940 x_right_overwritten (s
)
2941 struct glyph_string
*s
;
2945 if (s
->right_overhang
)
2948 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2949 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
2950 int end
= s
->row
->used
[s
->area
];
2952 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
2953 x
+= glyphs
[i
].pixel_width
;
2962 /* Return the index of the last glyph following glyph string S that
2963 overwrites S because of its left overhang. Value is negative
2964 if no such glyph is found. */
2967 x_right_overwriting (s
)
2968 struct glyph_string
*s
;
2971 int end
= s
->row
->used
[s
->area
];
2972 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2973 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
2977 for (i
= first
; i
< end
; ++i
)
2980 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
2983 x
+= glyphs
[i
].pixel_width
;
2990 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
2993 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
2994 struct glyph_string
*s
;
2998 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
2999 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3000 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3001 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3005 /* Draw the background of glyph_string S. If S->background_filled_p
3006 is non-zero don't draw it. FORCE_P non-zero means draw the
3007 background even if it wouldn't be drawn normally. This is used
3008 when a string preceding S draws into the background of S, or S
3009 contains the first component of a composition. */
3012 x_draw_glyph_string_background (s
, force_p
)
3013 struct glyph_string
*s
;
3016 /* Nothing to do if background has already been drawn or if it
3017 shouldn't be drawn in the first place. */
3018 if (!s
->background_filled_p
)
3022 /* Fill background with a stipple pattern. */
3023 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3024 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3025 s
->y
+ s
->face
->box_line_width
,
3026 s
->background_width
,
3027 s
->height
- 2 * s
->face
->box_line_width
);
3028 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3029 s
->background_filled_p
= 1;
3031 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * s
->face
->box_line_width
3032 || s
->font_not_found_p
3033 || s
->extends_to_end_of_line_p
3036 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ s
->face
->box_line_width
,
3037 s
->background_width
,
3038 s
->height
- 2 * s
->face
->box_line_width
);
3039 s
->background_filled_p
= 1;
3045 /* Draw the foreground of glyph string S. */
3048 x_draw_glyph_string_foreground (s
)
3049 struct glyph_string
*s
;
3053 /* If first glyph of S has a left box line, start drawing the text
3054 of S to the right of that box line. */
3055 if (s
->face
->box
!= FACE_NO_BOX
3056 && s
->first_glyph
->left_box_line_p
)
3057 x
= s
->x
+ s
->face
->box_line_width
;
3061 /* Draw characters of S as rectangles if S's font could not be
3063 if (s
->font_not_found_p
)
3065 for (i
= 0; i
< s
->nchars
; ++i
)
3067 struct glyph
*g
= s
->first_glyph
+ i
;
3068 XDrawRectangle (s
->display
, s
->window
,
3069 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3071 x
+= g
->pixel_width
;
3076 char *char1b
= (char *) s
->char2b
;
3077 int boff
= s
->font_info
->baseline_offset
;
3079 if (s
->font_info
->vertical_centering
)
3080 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3082 /* If we can use 8-bit functions, condense S->char2b. */
3084 for (i
= 0; i
< s
->nchars
; ++i
)
3085 char1b
[i
] = s
->char2b
[i
].byte2
;
3087 /* Draw text with XDrawString if background has already been
3088 filled. Otherwise, use XDrawImageString. (Note that
3089 XDrawImageString is usually faster than XDrawString.) Always
3090 use XDrawImageString when drawing the cursor so that there is
3091 no chance that characters under a box cursor are invisible. */
3092 if (s
->for_overlaps_p
3093 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3095 /* Draw characters with 16-bit or 8-bit functions. */
3097 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
3098 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3100 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
3101 s
->ybase
- boff
, char1b
, s
->nchars
);
3106 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
3107 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3109 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
3110 s
->ybase
- boff
, char1b
, s
->nchars
);
3115 /* Draw the foreground of composite glyph string S. */
3118 x_draw_composite_glyph_string_foreground (s
)
3119 struct glyph_string
*s
;
3123 /* If first glyph of S has a left box line, start drawing the text
3124 of S to the right of that box line. */
3125 if (s
->face
->box
!= FACE_NO_BOX
3126 && s
->first_glyph
->left_box_line_p
)
3127 x
= s
->x
+ s
->face
->box_line_width
;
3131 /* S is a glyph string for a composition. S->gidx is the index of
3132 the first character drawn for glyphs of this composition.
3133 S->gidx == 0 means we are drawing the very first character of
3134 this composition. */
3136 /* Draw a rectangle for the composition if the font for the very
3137 first character of the composition could not be loaded. */
3138 if (s
->font_not_found_p
)
3141 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
3142 s
->width
- 1, s
->height
- 1);
3146 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3147 XDrawString16 (s
->display
, s
->window
, s
->gc
,
3148 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3149 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3155 #ifdef USE_X_TOOLKIT
3157 /* Allocate the color COLOR->pixel on the screen and display of
3158 widget WIDGET in colormap CMAP. If an exact match cannot be
3159 allocated, try the nearest color available. Value is non-zero
3160 if successful. This is called from lwlib. */
3163 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3169 struct x_display_info
*dpyinfo
;
3172 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3174 /* Find the top-level shell of the widget. Note that this function
3175 can be called when the widget is not yet realized, so XtWindow
3176 (widget) == 0. That's the reason we can't simply use
3177 x_any_window_to_frame. */
3178 while (!XtIsTopLevelShell (widget
))
3179 widget
= XtParent (widget
);
3181 /* Look for a frame with that top-level widget. Allocate the color
3182 on that frame to get the right gamma correction value. */
3183 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3184 if (GC_FRAMEP (XCAR (tail
))
3185 && (f
= XFRAME (XCAR (tail
)),
3186 (f
->output_data
.nothing
!= 1
3187 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3188 && f
->output_data
.x
->widget
== widget
)
3189 return x_alloc_nearest_color (f
, cmap
, color
);
3194 #endif /* USE_X_TOOLKIT */
3197 /* Allocate the color COLOR->pixel on SCREEN of DISPLAY, colormap
3198 CMAP. If an exact match can't be allocated, try the nearest color
3199 available. Value is non-zero if successful. Set *COLOR to the
3203 x_alloc_nearest_color (f
, cmap
, color
)
3208 Display
*display
= FRAME_X_DISPLAY (f
);
3209 Screen
*screen
= FRAME_X_SCREEN (f
);
3212 gamma_correct (f
, color
);
3213 rc
= XAllocColor (display
, cmap
, color
);
3216 /* If we got to this point, the colormap is full, so we're going
3217 to try to get the next closest color. The algorithm used is
3218 a least-squares matching, which is what X uses for closest
3219 color matching with StaticColor visuals. */
3221 unsigned long nearest_delta
= ~0;
3222 int ncells
= XDisplayCells (display
, XScreenNumberOfScreen (screen
));
3223 XColor
*cells
= (XColor
*) alloca (ncells
* sizeof *cells
);
3225 for (i
= 0; i
< ncells
; ++i
)
3227 XQueryColors (display
, cmap
, cells
, ncells
);
3229 for (nearest
= i
= 0; i
< ncells
; ++i
)
3231 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3232 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3233 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3234 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3236 if (delta
< nearest_delta
)
3239 nearest_delta
= delta
;
3243 color
->red
= cells
[nearest
].red
;
3244 color
->green
= cells
[nearest
].green
;
3245 color
->blue
= cells
[nearest
].blue
;
3246 rc
= XAllocColor (display
, cmap
, color
);
3249 #ifdef DEBUG_X_COLORS
3251 register_color (color
->pixel
);
3252 #endif /* DEBUG_X_COLORS */
3258 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3259 It's necessary to do this instead of just using PIXEL directly to
3260 get color reference counts right. */
3263 x_copy_color (f
, pixel
)
3265 unsigned long pixel
;
3269 color
.pixel
= pixel
;
3271 XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3272 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3274 #ifdef DEBUG_X_COLORS
3275 register_color (pixel
);
3281 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3282 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3283 If this produces the same color as PIXEL, try a color where all RGB
3284 values have DELTA added. Return the allocated color in *PIXEL.
3285 DISPLAY is the X display, CMAP is the colormap to operate on.
3286 Value is non-zero if successful. */
3289 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
3293 unsigned long *pixel
;
3300 /* Get RGB color values. */
3301 color
.pixel
= *pixel
;
3302 XQueryColor (display
, cmap
, &color
);
3304 /* Change RGB values by specified FACTOR. Avoid overflow! */
3305 xassert (factor
>= 0);
3306 new.red
= min (0xffff, factor
* color
.red
);
3307 new.green
= min (0xffff, factor
* color
.green
);
3308 new.blue
= min (0xffff, factor
* color
.blue
);
3310 /* Try to allocate the color. */
3311 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3314 if (new.pixel
== *pixel
)
3316 /* If we end up with the same color as before, try adding
3317 delta to the RGB values. */
3318 x_free_colors (f
, &new.pixel
, 1);
3320 new.red
= min (0xffff, delta
+ color
.red
);
3321 new.green
= min (0xffff, delta
+ color
.green
);
3322 new.blue
= min (0xffff, delta
+ color
.blue
);
3323 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3334 /* Set up the foreground color for drawing relief lines of glyph
3335 string S. RELIEF is a pointer to a struct relief containing the GC
3336 with which lines will be drawn. Use a color that is FACTOR or
3337 DELTA lighter or darker than the relief's background which is found
3338 in S->f->output_data.x->relief_background. If such a color cannot
3339 be allocated, use DEFAULT_PIXEL, instead. */
3342 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3344 struct relief
*relief
;
3347 unsigned long default_pixel
;
3350 struct x_output
*di
= f
->output_data
.x
;
3351 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
3352 unsigned long pixel
;
3353 unsigned long background
= di
->relief_background
;
3354 Colormap cmap
= FRAME_X_COLORMAP (f
);
3355 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3356 Display
*dpy
= FRAME_X_DISPLAY (f
);
3358 xgcv
.graphics_exposures
= False
;
3359 xgcv
.line_width
= 1;
3361 /* Free previously allocated color. The color cell will be reused
3362 when it has been freed as many times as it was allocated, so this
3363 doesn't affect faces using the same colors. */
3365 && relief
->allocated_p
)
3367 /* If display has an immutable color map, freeing colors is not
3368 necessary and some servers don't allow it. So don't do it. */
3369 x_free_colors (f
, &relief
->pixel
, 1);
3370 relief
->allocated_p
= 0;
3373 /* Allocate new color. */
3374 xgcv
.foreground
= default_pixel
;
3376 if (dpyinfo
->n_planes
!= 1
3377 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
3379 relief
->allocated_p
= 1;
3380 xgcv
.foreground
= relief
->pixel
= pixel
;
3383 if (relief
->gc
== 0)
3385 xgcv
.stipple
= dpyinfo
->gray
;
3387 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
3390 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
3394 /* Set up colors for the relief lines around glyph string S. */
3397 x_setup_relief_colors (s
)
3398 struct glyph_string
*s
;
3400 struct x_output
*di
= s
->f
->output_data
.x
;
3401 unsigned long color
;
3403 if (s
->face
->use_box_color_for_shadows_p
)
3404 color
= s
->face
->box_color
;
3409 /* Get the background color of the face. */
3410 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3411 color
= xgcv
.background
;
3414 if (di
->white_relief
.gc
== 0
3415 || color
!= di
->relief_background
)
3417 di
->relief_background
= color
;
3418 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3419 WHITE_PIX_DEFAULT (s
->f
));
3420 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3421 BLACK_PIX_DEFAULT (s
->f
));
3426 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3427 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3428 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3429 relief. LEFT_P non-zero means draw a relief on the left side of
3430 the rectangle. RIGHT_P non-zero means draw a relief on the right
3431 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3435 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3436 raised_p
, left_p
, right_p
, clip_rect
)
3438 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3439 XRectangle
*clip_rect
;
3445 gc
= f
->output_data
.x
->white_relief
.gc
;
3447 gc
= f
->output_data
.x
->black_relief
.gc
;
3448 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3451 for (i
= 0; i
< width
; ++i
)
3452 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3453 left_x
+ i
* left_p
, top_y
+ i
,
3454 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3458 for (i
= 0; i
< width
; ++i
)
3459 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3460 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
);
3462 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3464 gc
= f
->output_data
.x
->black_relief
.gc
;
3466 gc
= f
->output_data
.x
->white_relief
.gc
;
3467 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3470 for (i
= 0; i
< width
; ++i
)
3471 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3472 left_x
+ i
* left_p
, bottom_y
- i
,
3473 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3477 for (i
= 0; i
< width
; ++i
)
3478 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3479 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3481 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3485 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3486 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3487 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3488 left side of the rectangle. RIGHT_P non-zero means draw a line
3489 on the right side of the rectangle. CLIP_RECT is the clipping
3490 rectangle to use when drawing. */
3493 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3494 left_p
, right_p
, clip_rect
)
3495 struct glyph_string
*s
;
3496 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
;
3497 XRectangle
*clip_rect
;
3501 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3502 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3503 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
3506 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3507 left_x
, top_y
, right_x
- left_x
, width
);
3511 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3512 left_x
, top_y
, width
, bottom_y
- top_y
);
3515 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3516 left_x
, bottom_y
- width
, right_x
- left_x
, width
);
3520 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3521 right_x
- width
, top_y
, width
, bottom_y
- top_y
);
3523 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3524 XSetClipMask (s
->display
, s
->gc
, None
);
3528 /* Draw a box around glyph string S. */
3531 x_draw_glyph_string_box (s
)
3532 struct glyph_string
*s
;
3534 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3535 int left_p
, right_p
;
3536 struct glyph
*last_glyph
;
3537 XRectangle clip_rect
;
3539 last_x
= window_box_right (s
->w
, s
->area
);
3540 if (s
->row
->full_width_p
3541 && !s
->w
->pseudo_window_p
)
3543 last_x
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s
->f
);
3544 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
3545 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
3548 /* The glyph that may have a right box line. */
3549 last_glyph
= (s
->cmp
|| s
->img
3551 : s
->first_glyph
+ s
->nchars
- 1);
3553 width
= s
->face
->box_line_width
;
3554 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3556 right_x
= ((s
->row
->full_width_p
3558 : min (last_x
, s
->x
+ s
->background_width
) - 1));
3560 bottom_y
= top_y
+ s
->height
- 1;
3562 left_p
= (s
->first_glyph
->left_box_line_p
3563 || (s
->hl
== DRAW_MOUSE_FACE
3565 || s
->prev
->hl
!= s
->hl
)));
3566 right_p
= (last_glyph
->right_box_line_p
3567 || (s
->hl
== DRAW_MOUSE_FACE
3569 || s
->next
->hl
!= s
->hl
)));
3571 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3573 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3574 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3575 left_p
, right_p
, &clip_rect
);
3578 x_setup_relief_colors (s
);
3579 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3580 width
, raised_p
, left_p
, right_p
, &clip_rect
);
3585 /* Draw foreground of image glyph string S. */
3588 x_draw_image_foreground (s
)
3589 struct glyph_string
*s
;
3592 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3594 /* If first glyph of S has a left box line, start drawing it to the
3595 right of that line. */
3596 if (s
->face
->box
!= FACE_NO_BOX
3597 && s
->first_glyph
->left_box_line_p
)
3598 x
= s
->x
+ s
->face
->box_line_width
;
3602 /* If there is a margin around the image, adjust x- and y-position
3606 x
+= s
->img
->margin
;
3607 y
+= s
->img
->margin
;
3614 /* We can't set both a clip mask and use XSetClipRectangles
3615 because the latter also sets a clip mask. We also can't
3616 trust on the shape extension to be available
3617 (XShapeCombineRegion). So, compute the rectangle to draw
3619 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3622 XRectangle clip_rect
, image_rect
, r
;
3624 xgcv
.clip_mask
= s
->img
->mask
;
3625 xgcv
.clip_x_origin
= x
;
3626 xgcv
.clip_y_origin
= y
;
3627 xgcv
.function
= GXcopy
;
3628 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3630 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3633 image_rect
.width
= s
->img
->width
;
3634 image_rect
.height
= s
->img
->height
;
3635 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
3636 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3637 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
3641 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3642 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3644 /* When the image has a mask, we can expect that at
3645 least part of a mouse highlight or a block cursor will
3646 be visible. If the image doesn't have a mask, make
3647 a block cursor visible by drawing a rectangle around
3648 the image. I believe it's looking better if we do
3649 nothing here for mouse-face. */
3650 if (s
->hl
== DRAW_CURSOR
)
3651 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
3652 s
->img
->width
- 1, s
->img
->height
- 1);
3656 /* Draw a rectangle if image could not be loaded. */
3657 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
3658 s
->img
->width
- 1, s
->img
->height
- 1);
3662 /* Draw a relief around the image glyph string S. */
3665 x_draw_image_relief (s
)
3666 struct glyph_string
*s
;
3668 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3671 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3673 /* If first glyph of S has a left box line, start drawing it to the
3674 right of that line. */
3675 if (s
->face
->box
!= FACE_NO_BOX
3676 && s
->first_glyph
->left_box_line_p
)
3677 x
= s
->x
+ s
->face
->box_line_width
;
3681 /* If there is a margin around the image, adjust x- and y-position
3685 x
+= s
->img
->margin
;
3686 y
+= s
->img
->margin
;
3689 if (s
->hl
== DRAW_IMAGE_SUNKEN
3690 || s
->hl
== DRAW_IMAGE_RAISED
)
3692 thick
= tool_bar_button_relief
> 0 ? tool_bar_button_relief
: 3;
3693 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3697 thick
= abs (s
->img
->relief
);
3698 raised_p
= s
->img
->relief
> 0;
3703 x1
= x
+ s
->img
->width
+ thick
- 1;
3704 y1
= y
+ s
->img
->height
+ thick
- 1;
3706 x_setup_relief_colors (s
);
3707 x_get_glyph_string_clip_rect (s
, &r
);
3708 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
3712 /* Draw the foreground of image glyph string S to PIXMAP. */
3715 x_draw_image_foreground_1 (s
, pixmap
)
3716 struct glyph_string
*s
;
3720 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
3722 /* If first glyph of S has a left box line, start drawing it to the
3723 right of that line. */
3724 if (s
->face
->box
!= FACE_NO_BOX
3725 && s
->first_glyph
->left_box_line_p
)
3726 x
= s
->face
->box_line_width
;
3730 /* If there is a margin around the image, adjust x- and y-position
3734 x
+= s
->img
->margin
;
3735 y
+= s
->img
->margin
;
3742 /* We can't set both a clip mask and use XSetClipRectangles
3743 because the latter also sets a clip mask. We also can't
3744 trust on the shape extension to be available
3745 (XShapeCombineRegion). So, compute the rectangle to draw
3747 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3751 xgcv
.clip_mask
= s
->img
->mask
;
3752 xgcv
.clip_x_origin
= x
;
3753 xgcv
.clip_y_origin
= y
;
3754 xgcv
.function
= GXcopy
;
3755 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3757 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3758 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3759 XSetClipMask (s
->display
, s
->gc
, None
);
3763 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3764 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3766 /* When the image has a mask, we can expect that at
3767 least part of a mouse highlight or a block cursor will
3768 be visible. If the image doesn't have a mask, make
3769 a block cursor visible by drawing a rectangle around
3770 the image. I believe it's looking better if we do
3771 nothing here for mouse-face. */
3772 if (s
->hl
== DRAW_CURSOR
)
3773 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
3774 s
->img
->width
- 1, s
->img
->height
- 1);
3778 /* Draw a rectangle if image could not be loaded. */
3779 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
3780 s
->img
->width
- 1, s
->img
->height
- 1);
3784 /* Draw part of the background of glyph string S. X, Y, W, and H
3785 give the rectangle to draw. */
3788 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
3789 struct glyph_string
*s
;
3794 /* Fill background with a stipple pattern. */
3795 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3796 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3797 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3800 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
3804 /* Draw image glyph string S.
3807 s->x +-------------------------
3810 | +-------------------------
3813 | | +-------------------
3819 x_draw_image_glyph_string (s
)
3820 struct glyph_string
*s
;
3823 int box_line_width
= s
->face
->box_line_width
;
3824 int margin
= s
->img
->margin
;
3826 Pixmap pixmap
= None
;
3828 height
= s
->height
- 2 * box_line_width
;
3830 /* Fill background with face under the image. Do it only if row is
3831 taller than image or if image has a clip mask to reduce
3833 s
->stippled_p
= s
->face
->stipple
!= 0;
3834 if (height
> s
->img
->height
3837 || s
->img
->pixmap
== 0
3838 || s
->width
!= s
->background_width
)
3840 if (box_line_width
&& s
->first_glyph
->left_box_line_p
)
3841 x
= s
->x
+ box_line_width
;
3845 y
= s
->y
+ box_line_width
;
3849 /* Create a pixmap as large as the glyph string Fill it with
3850 the background color. Copy the image to it, using its
3851 mask. Copy the temporary pixmap to the display. */
3852 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
3853 int depth
= DefaultDepthOfScreen (screen
);
3855 /* Create a pixmap as large as the glyph string. */
3856 pixmap
= XCreatePixmap (s
->display
, s
->window
,
3857 s
->background_width
,
3860 /* Don't clip in the following because we're working on the
3862 XSetClipMask (s
->display
, s
->gc
, None
);
3864 /* Fill the pixmap with the background color/stipple. */
3867 /* Fill background with a stipple pattern. */
3868 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3869 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3870 0, 0, s
->background_width
, s
->height
);
3871 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3876 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
3878 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3879 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3880 0, 0, s
->background_width
, s
->height
);
3881 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3885 /* Implementation idea: Is it possible to construct a mask?
3886 We could look at the color at the margins of the image, and
3887 say that this color is probably the background color of the
3889 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
3891 s
->background_filled_p
= 1;
3894 /* Draw the foreground. */
3897 x_draw_image_foreground_1 (s
, pixmap
);
3898 x_set_glyph_string_clipping (s
);
3899 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
3900 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
3901 XFreePixmap (s
->display
, pixmap
);
3904 x_draw_image_foreground (s
);
3906 /* If we must draw a relief around the image, do it. */
3908 || s
->hl
== DRAW_IMAGE_RAISED
3909 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3910 x_draw_image_relief (s
);
3914 /* Draw stretch glyph string S. */
3917 x_draw_stretch_glyph_string (s
)
3918 struct glyph_string
*s
;
3920 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
3921 s
->stippled_p
= s
->face
->stipple
!= 0;
3923 if (s
->hl
== DRAW_CURSOR
3924 && !x_stretch_cursor_p
)
3926 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
3927 as wide as the stretch glyph. */
3928 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
3931 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
3933 /* Clear rest using the GC of the original non-cursor face. */
3934 if (width
< s
->background_width
)
3936 GC gc
= s
->face
->gc
;
3937 int x
= s
->x
+ width
, y
= s
->y
;
3938 int w
= s
->background_width
- width
, h
= s
->height
;
3941 x_get_glyph_string_clip_rect (s
, &r
);
3942 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
3944 if (s
->face
->stipple
)
3946 /* Fill background with a stipple pattern. */
3947 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
3948 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
3949 XSetFillStyle (s
->display
, gc
, FillSolid
);
3954 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
3955 XSetForeground (s
->display
, gc
, xgcv
.background
);
3956 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
3957 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
3962 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
3965 s
->background_filled_p
= 1;
3969 /* Draw glyph string S. */
3972 x_draw_glyph_string (s
)
3973 struct glyph_string
*s
;
3975 /* If S draws into the background of its successor, draw the
3976 background of the successor first so that S can draw into it.
3977 This makes S->next use XDrawString instead of XDrawImageString. */
3978 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
3980 xassert (s
->next
->img
== NULL
);
3981 x_set_glyph_string_gc (s
->next
);
3982 x_set_glyph_string_clipping (s
->next
);
3983 x_draw_glyph_string_background (s
->next
, 1);
3986 /* Set up S->gc, set clipping and draw S. */
3987 x_set_glyph_string_gc (s
);
3988 x_set_glyph_string_clipping (s
);
3990 switch (s
->first_glyph
->type
)
3993 x_draw_image_glyph_string (s
);
3997 x_draw_stretch_glyph_string (s
);
4001 if (s
->for_overlaps_p
)
4002 s
->background_filled_p
= 1;
4004 x_draw_glyph_string_background (s
, 0);
4005 x_draw_glyph_string_foreground (s
);
4008 case COMPOSITE_GLYPH
:
4009 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4010 s
->background_filled_p
= 1;
4012 x_draw_glyph_string_background (s
, 1);
4013 x_draw_composite_glyph_string_foreground (s
);
4020 if (!s
->for_overlaps_p
)
4022 /* Draw underline. */
4023 if (s
->face
->underline_p
)
4025 unsigned long dy
, h
;
4027 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
4029 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &dy
))
4032 if (s
->face
->underline_defaulted_p
)
4033 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4038 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4039 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
4040 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4042 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4046 /* Draw overline. */
4047 if (s
->face
->overline_p
)
4049 unsigned long dy
= 0, h
= 1;
4051 if (s
->face
->overline_color_defaulted_p
)
4052 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4057 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4058 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4059 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4061 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4065 /* Draw strike-through. */
4066 if (s
->face
->strike_through_p
)
4068 unsigned long h
= 1;
4069 unsigned long dy
= (s
->height
- h
) / 2;
4071 if (s
->face
->strike_through_color_defaulted_p
)
4072 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4077 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4078 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4079 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4081 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4086 if (s
->face
->box
!= FACE_NO_BOX
)
4087 x_draw_glyph_string_box (s
);
4090 /* Reset clipping. */
4091 XSetClipMask (s
->display
, s
->gc
, None
);
4095 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4096 struct face
**, int));
4099 /* Load glyph string S with a composition components specified by S->cmp.
4100 FACES is an array of faces for all components of this composition.
4101 S->gidx is the index of the first component for S.
4102 OVERLAPS_P non-zero means S should draw the foreground only, and
4103 use its lines physical height for clipping.
4105 Value is the index of a component not in S. */
4108 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4109 struct glyph_string
*s
;
4110 struct face
**faces
;
4117 s
->for_overlaps_p
= overlaps_p
;
4119 s
->face
= faces
[s
->gidx
];
4120 s
->font
= s
->face
->font
;
4121 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4123 /* For all glyphs of this composition, starting at the offset
4124 S->gidx, until we reach the end of the definition or encounter a
4125 glyph that requires the different face, add it to S. */
4127 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4130 /* All glyph strings for the same composition has the same width,
4131 i.e. the width set for the first component of the composition. */
4133 s
->width
= s
->first_glyph
->pixel_width
;
4135 /* If the specified font could not be loaded, use the frame's
4136 default font, but record the fact that we couldn't load it in
4137 the glyph string so that we can draw rectangles for the
4138 characters of the glyph string. */
4139 if (s
->font
== NULL
)
4141 s
->font_not_found_p
= 1;
4142 s
->font
= FRAME_FONT (s
->f
);
4145 /* Adjust base line for subscript/superscript text. */
4146 s
->ybase
+= s
->first_glyph
->voffset
;
4148 xassert (s
->face
&& s
->face
->gc
);
4150 /* This glyph string must always be drawn with 16-bit functions. */
4153 return s
->gidx
+ s
->nchars
;
4157 /* Load glyph string S with a sequence characters.
4158 FACE_ID is the face id of the string. START is the index of the
4159 first glyph to consider, END is the index of the last + 1.
4160 OVERLAPS_P non-zero means S should draw the foreground only, and
4161 use its lines physical height for clipping.
4163 Value is the index of the first glyph not in S. */
4166 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4167 struct glyph_string
*s
;
4169 int start
, end
, overlaps_p
;
4171 struct glyph
*glyph
, *last
;
4173 int glyph_not_available_p
;
4175 xassert (s
->f
== XFRAME (s
->w
->frame
));
4176 xassert (s
->nchars
== 0);
4177 xassert (start
>= 0 && end
> start
);
4179 s
->for_overlaps_p
= overlaps_p
,
4180 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4181 last
= s
->row
->glyphs
[s
->area
] + end
;
4182 voffset
= glyph
->voffset
;
4184 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4187 && glyph
->type
== CHAR_GLYPH
4188 && glyph
->voffset
== voffset
4189 /* Same face id implies same font, nowadays. */
4190 && glyph
->face_id
== face_id
4191 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4195 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4196 s
->char2b
+ s
->nchars
,
4198 s
->two_byte_p
= two_byte_p
;
4200 xassert (s
->nchars
<= end
- start
);
4201 s
->width
+= glyph
->pixel_width
;
4205 s
->font
= s
->face
->font
;
4206 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4208 /* If the specified font could not be loaded, use the frame's font,
4209 but record the fact that we couldn't load it in
4210 S->font_not_found_p so that we can draw rectangles for the
4211 characters of the glyph string. */
4212 if (s
->font
== NULL
|| glyph_not_available_p
)
4214 s
->font_not_found_p
= 1;
4215 s
->font
= FRAME_FONT (s
->f
);
4218 /* Adjust base line for subscript/superscript text. */
4219 s
->ybase
+= voffset
;
4221 xassert (s
->face
&& s
->face
->gc
);
4222 return glyph
- s
->row
->glyphs
[s
->area
];
4226 /* Fill glyph string S from image glyph S->first_glyph. */
4229 x_fill_image_glyph_string (s
)
4230 struct glyph_string
*s
;
4232 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4233 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4235 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4236 s
->font
= s
->face
->font
;
4237 s
->width
= s
->first_glyph
->pixel_width
;
4239 /* Adjust base line for subscript/superscript text. */
4240 s
->ybase
+= s
->first_glyph
->voffset
;
4244 /* Fill glyph string S from stretch glyph S->first_glyph. */
4247 x_fill_stretch_glyph_string (s
)
4248 struct glyph_string
*s
;
4250 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4251 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4252 s
->font
= s
->face
->font
;
4253 s
->width
= s
->first_glyph
->pixel_width
;
4255 /* Adjust base line for subscript/superscript text. */
4256 s
->ybase
+= s
->first_glyph
->voffset
;
4260 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4261 of XChar2b structures for S; it can't be allocated in
4262 x_init_glyph_string because it must be allocated via `alloca'. W
4263 is the window on which S is drawn. ROW and AREA are the glyph row
4264 and area within the row from which S is constructed. START is the
4265 index of the first glyph structure covered by S. HL is a
4266 face-override for drawing S. */
4269 x_init_glyph_string (s
, char2b
, w
, row
, area
, start
, hl
)
4270 struct glyph_string
*s
;
4273 struct glyph_row
*row
;
4274 enum glyph_row_area area
;
4276 enum draw_glyphs_face hl
;
4278 bzero (s
, sizeof *s
);
4280 s
->f
= XFRAME (w
->frame
);
4281 s
->display
= FRAME_X_DISPLAY (s
->f
);
4282 s
->window
= FRAME_X_WINDOW (s
->f
);
4287 s
->first_glyph
= row
->glyphs
[area
] + start
;
4288 s
->height
= row
->height
;
4289 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4291 /* Display the internal border below the tool-bar window. */
4292 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4293 s
->y
-= s
->f
->output_data
.x
->internal_border_width
;
4295 s
->ybase
= s
->y
+ row
->ascent
;
4299 /* Set background width of glyph string S. START is the index of the
4300 first glyph following S. LAST_X is the right-most x-position + 1
4301 in the drawing area. */
4304 x_set_glyph_string_background_width (s
, start
, last_x
)
4305 struct glyph_string
*s
;
4309 /* If the face of this glyph string has to be drawn to the end of
4310 the drawing area, set S->extends_to_end_of_line_p. */
4311 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4313 if (start
== s
->row
->used
[s
->area
]
4314 && s
->hl
== DRAW_NORMAL_TEXT
4315 && ((s
->area
== TEXT_AREA
&& s
->row
->fill_line_p
)
4316 || s
->face
->background
!= default_face
->background
4317 || s
->face
->stipple
!= default_face
->stipple
))
4318 s
->extends_to_end_of_line_p
= 1;
4320 /* If S extends its face to the end of the line, set its
4321 background_width to the distance to the right edge of the drawing
4323 if (s
->extends_to_end_of_line_p
)
4324 s
->background_width
= last_x
- s
->x
+ 1;
4326 s
->background_width
= s
->width
;
4330 /* Add a glyph string for a stretch glyph to the list of strings
4331 between HEAD and TAIL. START is the index of the stretch glyph in
4332 row area AREA of glyph row ROW. END is the index of the last glyph
4333 in that glyph row area. X is the current output position assigned
4334 to the new glyph string constructed. HL overrides that face of the
4335 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4336 is the right-most x-position of the drawing area. */
4338 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4339 and below -- keep them on one line. */
4340 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4343 s = (struct glyph_string *) alloca (sizeof *s); \
4344 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4345 x_fill_stretch_glyph_string (s); \
4346 x_append_glyph_string (&HEAD, &TAIL, s); \
4353 /* Add a glyph string for an image glyph to the list of strings
4354 between HEAD and TAIL. START is the index of the image glyph in
4355 row area AREA of glyph row ROW. END is the index of the last glyph
4356 in that glyph row area. X is the current output position assigned
4357 to the new glyph string constructed. HL overrides that face of the
4358 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4359 is the right-most x-position of the drawing area. */
4361 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4364 s = (struct glyph_string *) alloca (sizeof *s); \
4365 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4366 x_fill_image_glyph_string (s); \
4367 x_append_glyph_string (&HEAD, &TAIL, s); \
4374 /* Add a glyph string for a sequence of character glyphs to the list
4375 of strings between HEAD and TAIL. START is the index of the first
4376 glyph in row area AREA of glyph row ROW that is part of the new
4377 glyph string. END is the index of the last glyph in that glyph row
4378 area. X is the current output position assigned to the new glyph
4379 string constructed. HL overrides that face of the glyph; e.g. it
4380 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4381 right-most x-position of the drawing area. */
4383 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4386 int c, charset, face_id; \
4389 c = (ROW)->glyphs[AREA][START].u.ch; \
4390 face_id = (ROW)->glyphs[AREA][START].face_id; \
4392 s = (struct glyph_string *) alloca (sizeof *s); \
4393 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4394 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4395 x_append_glyph_string (&HEAD, &TAIL, s); \
4397 START = x_fill_glyph_string (s, face_id, START, END, \
4403 /* Add a glyph string for a composite sequence to the list of strings
4404 between HEAD and TAIL. START is the index of the first glyph in
4405 row area AREA of glyph row ROW that is part of the new glyph
4406 string. END is the index of the last glyph in that glyph row area.
4407 X is the current output position assigned to the new glyph string
4408 constructed. HL overrides that face of the glyph; e.g. it is
4409 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4410 x-position of the drawing area. */
4412 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4414 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4415 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4416 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4417 struct composition *cmp = composition_table[cmp_id]; \
4418 int glyph_len = cmp->glyph_len; \
4420 struct face **faces; \
4421 struct glyph_string *first_s = NULL; \
4424 base_face = base_face->ascii_face; \
4425 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4426 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4427 /* At first, fill in `char2b' and `faces'. */ \
4428 for (n = 0; n < glyph_len; n++) \
4430 int c = COMPOSITION_GLYPH (cmp, n); \
4431 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4432 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4433 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4434 this_face_id, char2b + n, 1); \
4437 /* Make glyph_strings for each glyph sequence that is drawable by \
4438 the same face, and append them to HEAD/TAIL. */ \
4439 for (n = 0; n < cmp->glyph_len;) \
4441 s = (struct glyph_string *) alloca (sizeof *s); \
4442 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
4443 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4451 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4459 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4460 of AREA of glyph row ROW on window W between indices START and END.
4461 HL overrides the face for drawing glyph strings, e.g. it is
4462 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4463 x-positions of the drawing area.
4465 This is an ugly monster macro construct because we must use alloca
4466 to allocate glyph strings (because x_draw_glyphs can be called
4469 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4472 HEAD = TAIL = NULL; \
4473 while (START < END) \
4475 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4476 switch (first_glyph->type) \
4479 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
4480 TAIL, HL, X, LAST_X, \
4484 case COMPOSITE_GLYPH: \
4485 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
4486 HEAD, TAIL, HL, X, LAST_X,\
4490 case STRETCH_GLYPH: \
4491 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
4492 HEAD, TAIL, HL, X, LAST_X); \
4496 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
4497 TAIL, HL, X, LAST_X); \
4504 x_set_glyph_string_background_width (s, START, LAST_X); \
4511 /* Draw glyphs between START and END in AREA of ROW on window W,
4512 starting at x-position X. X is relative to AREA in W. HL is a
4513 face-override with the following meaning:
4515 DRAW_NORMAL_TEXT draw normally
4516 DRAW_CURSOR draw in cursor face
4517 DRAW_MOUSE_FACE draw in mouse face.
4518 DRAW_INVERSE_VIDEO draw in mode line face
4519 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
4520 DRAW_IMAGE_RAISED draw an image with a raised relief around it
4522 If REAL_START is non-null, return in *REAL_START the real starting
4523 position for display. This can be different from START in case
4524 overlapping glyphs must be displayed. If REAL_END is non-null,
4525 return in *REAL_END the real end position for display. This can be
4526 different from END in case overlapping glyphs must be displayed.
4528 If OVERLAPS_P is non-zero, draw only the foreground of characters
4529 and clip to the physical height of ROW.
4531 Value is the x-position reached, relative to AREA of W. */
4534 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, real_start
, real_end
,
4538 struct glyph_row
*row
;
4539 enum glyph_row_area area
;
4541 enum draw_glyphs_face hl
;
4542 int *real_start
, *real_end
;
4545 struct glyph_string
*head
, *tail
;
4546 struct glyph_string
*s
;
4547 int last_x
, area_width
;
4551 /* Let's rather be paranoid than getting a SEGV. */
4552 start
= max (0, start
);
4553 end
= min (end
, row
->used
[area
]);
4555 *real_start
= start
;
4559 /* Translate X to frame coordinates. Set last_x to the right
4560 end of the drawing area. */
4561 if (row
->full_width_p
)
4563 /* X is relative to the left edge of W, without scroll bars
4565 struct frame
*f
= XFRAME (w
->frame
);
4566 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
4567 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
4570 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4571 last_x
= window_left_x
+ area_width
;
4573 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4575 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4576 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4582 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
4583 last_x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
4587 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
4588 area_width
= window_box_width (w
, area
);
4589 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
4592 /* Build a doubly-linked list of glyph_string structures between
4593 head and tail from what we have to draw. Note that the macro
4594 BUILD_GLYPH_STRINGS will modify its start parameter. That's
4595 the reason we use a separate variable `i'. */
4597 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
4600 x_reached
= tail
->x
+ tail
->background_width
;
4604 /* If there are any glyphs with lbearing < 0 or rbearing > width in
4605 the row, redraw some glyphs in front or following the glyph
4606 strings built above. */
4607 if (!overlaps_p
&& row
->contains_overlapping_glyphs_p
)
4610 struct glyph_string
*h
, *t
;
4612 /* Compute overhangs for all glyph strings. */
4613 for (s
= head
; s
; s
= s
->next
)
4614 x_compute_glyph_string_overhangs (s
);
4616 /* Prepend glyph strings for glyphs in front of the first glyph
4617 string that are overwritten because of the first glyph
4618 string's left overhang. The background of all strings
4619 prepended must be drawn because the first glyph string
4621 i
= x_left_overwritten (head
);
4625 BUILD_GLYPH_STRINGS (w
, row
, area
, j
, start
, h
, t
,
4626 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4630 *real_start
= start
;
4631 x_compute_overhangs_and_x (t
, head
->x
, 1);
4632 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4635 /* Prepend glyph strings for glyphs in front of the first glyph
4636 string that overwrite that glyph string because of their
4637 right overhang. For these strings, only the foreground must
4638 be drawn, because it draws over the glyph string at `head'.
4639 The background must not be drawn because this would overwrite
4640 right overhangs of preceding glyphs for which no glyph
4642 i
= x_left_overwriting (head
);
4645 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, start
, h
, t
,
4646 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4648 for (s
= h
; s
; s
= s
->next
)
4649 s
->background_filled_p
= 1;
4652 x_compute_overhangs_and_x (t
, head
->x
, 1);
4653 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4656 /* Append glyphs strings for glyphs following the last glyph
4657 string tail that are overwritten by tail. The background of
4658 these strings has to be drawn because tail's foreground draws
4660 i
= x_right_overwritten (tail
);
4663 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
4664 DRAW_NORMAL_TEXT
, x
, last_x
,
4666 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4667 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4672 /* Append glyph strings for glyphs following the last glyph
4673 string tail that overwrite tail. The foreground of such
4674 glyphs has to be drawn because it writes into the background
4675 of tail. The background must not be drawn because it could
4676 paint over the foreground of following glyphs. */
4677 i
= x_right_overwriting (tail
);
4680 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
4681 DRAW_NORMAL_TEXT
, x
, last_x
,
4683 for (s
= h
; s
; s
= s
->next
)
4684 s
->background_filled_p
= 1;
4685 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4686 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4692 /* Draw all strings. */
4693 for (s
= head
; s
; s
= s
->next
)
4694 x_draw_glyph_string (s
);
4696 /* Value is the x-position up to which drawn, relative to AREA of W.
4697 This doesn't include parts drawn because of overhangs. */
4698 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
4699 if (!row
->full_width_p
)
4701 if (area
> LEFT_MARGIN_AREA
)
4702 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
4703 if (area
> TEXT_AREA
)
4704 x_reached
-= window_box_width (w
, TEXT_AREA
);
4710 /* Fix the display of area AREA of overlapping row ROW in window W. */
4713 x_fix_overlapping_area (w
, row
, area
)
4715 struct glyph_row
*row
;
4716 enum glyph_row_area area
;
4722 if (area
== LEFT_MARGIN_AREA
)
4724 else if (area
== TEXT_AREA
)
4725 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
4727 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
4728 + window_box_width (w
, TEXT_AREA
));
4730 for (i
= 0; i
< row
->used
[area
];)
4732 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
4734 int start
= i
, start_x
= x
;
4738 x
+= row
->glyphs
[area
][i
].pixel_width
;
4741 while (i
< row
->used
[area
]
4742 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
4744 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
4746 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
4751 x
+= row
->glyphs
[area
][i
].pixel_width
;
4760 /* Output LEN glyphs starting at START at the nominal cursor position.
4761 Advance the nominal cursor over the text. The global variable
4762 updated_window contains the window being updated, updated_row is
4763 the glyph row being updated, and updated_area is the area of that
4764 row being updated. */
4767 x_write_glyphs (start
, len
)
4768 struct glyph
*start
;
4771 int x
, hpos
, real_start
, real_end
;
4773 xassert (updated_window
&& updated_row
);
4778 hpos
= start
- updated_row
->glyphs
[updated_area
];
4779 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
4780 updated_row
, updated_area
,
4782 (updated_row
->inverse_p
4783 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
4784 &real_start
, &real_end
, 0);
4786 /* If we drew over the cursor, note that it is not visible any more. */
4787 note_overwritten_text_cursor (updated_window
, real_start
,
4788 real_end
- real_start
);
4792 /* Advance the output cursor. */
4793 output_cursor
.hpos
+= len
;
4794 output_cursor
.x
= x
;
4798 /* Insert LEN glyphs from START at the nominal cursor position. */
4801 x_insert_glyphs (start
, len
)
4802 struct glyph
*start
;
4807 int line_height
, shift_by_width
, shifted_region_width
;
4808 struct glyph_row
*row
;
4809 struct glyph
*glyph
;
4810 int frame_x
, frame_y
, hpos
, real_start
, real_end
;
4812 xassert (updated_window
&& updated_row
);
4815 f
= XFRAME (WINDOW_FRAME (w
));
4817 /* Get the height of the line we are in. */
4819 line_height
= row
->height
;
4821 /* Get the width of the glyphs to insert. */
4823 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
4824 shift_by_width
+= glyph
->pixel_width
;
4826 /* Get the width of the region to shift right. */
4827 shifted_region_width
= (window_box_width (w
, updated_area
)
4832 frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, output_cursor
.x
);
4833 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
4834 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
4835 f
->output_data
.x
->normal_gc
,
4837 shifted_region_width
, line_height
,
4838 frame_x
+ shift_by_width
, frame_y
);
4840 /* Write the glyphs. */
4841 hpos
= start
- row
->glyphs
[updated_area
];
4842 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
4843 DRAW_NORMAL_TEXT
, &real_start
, &real_end
, 0);
4844 note_overwritten_text_cursor (w
, real_start
, real_end
- real_start
);
4846 /* Advance the output cursor. */
4847 output_cursor
.hpos
+= len
;
4848 output_cursor
.x
+= shift_by_width
;
4853 /* Delete N glyphs at the nominal cursor position. Not implemented
4864 /* Erase the current text line from the nominal cursor position
4865 (inclusive) to pixel column TO_X (exclusive). The idea is that
4866 everything from TO_X onward is already erased.
4868 TO_X is a pixel position relative to updated_area of
4869 updated_window. TO_X == -1 means clear to the end of this area. */
4872 x_clear_end_of_line (to_x
)
4876 struct window
*w
= updated_window
;
4877 int max_x
, min_y
, max_y
;
4878 int from_x
, from_y
, to_y
;
4880 xassert (updated_window
&& updated_row
);
4881 f
= XFRAME (w
->frame
);
4883 if (updated_row
->full_width_p
)
4885 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4886 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4887 && !w
->pseudo_window_p
)
4888 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4891 max_x
= window_box_width (w
, updated_area
);
4892 max_y
= window_text_bottom_y (w
);
4894 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
4895 of window. For TO_X > 0, truncate to end of drawing area. */
4901 to_x
= min (to_x
, max_x
);
4903 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
4905 /* Notice if the cursor will be cleared by this operation. */
4906 if (!updated_row
->full_width_p
)
4907 note_overwritten_text_cursor (w
, output_cursor
.hpos
, -1);
4909 from_x
= output_cursor
.x
;
4911 /* Translate to frame coordinates. */
4912 if (updated_row
->full_width_p
)
4914 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
4915 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
4919 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
4920 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
4923 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
4924 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
4925 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
4927 /* Prevent inadvertently clearing to end of the X window. */
4928 if (to_x
> from_x
&& to_y
> from_y
)
4931 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4932 from_x
, from_y
, to_x
- from_x
, to_y
- from_y
,
4939 /* Clear entire frame. If updating_frame is non-null, clear that
4940 frame. Otherwise clear the selected frame. */
4950 f
= SELECTED_FRAME ();
4952 /* Clearing the frame will erase any cursor, so mark them all as no
4954 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
4955 output_cursor
.hpos
= output_cursor
.vpos
= 0;
4956 output_cursor
.x
= -1;
4958 /* We don't set the output cursor here because there will always
4959 follow an explicit cursor_to. */
4961 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
4963 /* We have to clear the scroll bars, too. If we have changed
4964 colors or something like that, then they should be notified. */
4965 x_scroll_bar_clear (f
);
4967 XFlush (FRAME_X_DISPLAY (f
));
4973 /* Invert the middle quarter of the frame for .15 sec. */
4975 /* We use the select system call to do the waiting, so we have to make
4976 sure it's available. If it isn't, we just won't do visual bells. */
4978 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
4981 /* Subtract the `struct timeval' values X and Y, storing the result in
4982 *RESULT. Return 1 if the difference is negative, otherwise 0. */
4985 timeval_subtract (result
, x
, y
)
4986 struct timeval
*result
, x
, y
;
4988 /* Perform the carry for the later subtraction by updating y. This
4989 is safer because on some systems the tv_sec member is unsigned. */
4990 if (x
.tv_usec
< y
.tv_usec
)
4992 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
4993 y
.tv_usec
-= 1000000 * nsec
;
4997 if (x
.tv_usec
- y
.tv_usec
> 1000000)
4999 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
5000 y
.tv_usec
+= 1000000 * nsec
;
5004 /* Compute the time remaining to wait. tv_usec is certainly
5006 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
5007 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
5009 /* Return indication of whether the result should be considered
5011 return x
.tv_sec
< y
.tv_sec
;
5023 /* Create a GC that will use the GXxor function to flip foreground
5024 pixels into background pixels. */
5028 values
.function
= GXxor
;
5029 values
.foreground
= (f
->output_data
.x
->foreground_pixel
5030 ^ f
->output_data
.x
->background_pixel
);
5032 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5033 GCFunction
| GCForeground
, &values
);
5037 /* Get the height not including a menu bar widget. */
5038 int height
= CHAR_TO_PIXEL_HEIGHT (f
, FRAME_HEIGHT (f
));
5039 /* Height of each line to flash. */
5040 int flash_height
= FRAME_LINE_HEIGHT (f
);
5041 /* These will be the left and right margins of the rectangles. */
5042 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
5043 int flash_right
= PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
5047 /* Don't flash the area between a scroll bar and the frame
5048 edge it is next to. */
5049 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
5051 case vertical_scroll_bar_left
:
5052 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5055 case vertical_scroll_bar_right
:
5056 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5063 width
= flash_right
- flash_left
;
5065 /* If window is tall, flash top and bottom line. */
5066 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5068 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5070 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5071 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5072 width
, flash_height
);
5073 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5075 (height
- flash_height
5076 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5077 width
, flash_height
);
5080 /* If it is short, flash it all. */
5081 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5082 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5083 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5088 struct timeval wakeup
;
5090 EMACS_GET_TIME (wakeup
);
5092 /* Compute time to wait until, propagating carry from usecs. */
5093 wakeup
.tv_usec
+= 150000;
5094 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
5095 wakeup
.tv_usec
%= 1000000;
5097 /* Keep waiting until past the time wakeup. */
5100 struct timeval timeout
;
5102 EMACS_GET_TIME (timeout
);
5104 /* In effect, timeout = wakeup - timeout.
5105 Break if result would be negative. */
5106 if (timeval_subtract (&timeout
, wakeup
, timeout
))
5109 /* Try to wait that long--but we might wake up sooner. */
5110 select (0, NULL
, NULL
, NULL
, &timeout
);
5114 /* If window is tall, flash top and bottom line. */
5115 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5117 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5119 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5120 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5121 width
, flash_height
);
5122 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5124 (height
- flash_height
5125 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5126 width
, flash_height
);
5129 /* If it is short, flash it all. */
5130 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5131 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5132 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5134 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5142 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5145 /* Make audible bell. */
5150 struct frame
*f
= SELECTED_FRAME ();
5152 if (FRAME_X_DISPLAY (f
))
5154 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5161 XBell (FRAME_X_DISPLAY (f
), 0);
5162 XFlush (FRAME_X_DISPLAY (f
));
5169 /* Specify how many text lines, from the top of the window,
5170 should be affected by insert-lines and delete-lines operations.
5171 This, and those operations, are used only within an update
5172 that is bounded by calls to x_update_begin and x_update_end. */
5175 XTset_terminal_window (n
)
5178 /* This function intentionally left blank. */
5183 /***********************************************************************
5185 ***********************************************************************/
5187 /* Perform an insert-lines or delete-lines operation, inserting N
5188 lines or deleting -N lines at vertical position VPOS. */
5191 x_ins_del_lines (vpos
, n
)
5198 /* Scroll part of the display as described by RUN. */
5201 x_scroll_run (w
, run
)
5205 struct frame
*f
= XFRAME (w
->frame
);
5206 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5208 /* Get frame-relative bounding box of the text display area of W,
5209 without mode lines. Include in this box the flags areas to the
5210 left and right of W. */
5211 window_box (w
, -1, &x
, &y
, &width
, &height
);
5212 width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
5213 x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
5215 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5216 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5217 bottom_y
= y
+ height
;
5221 /* Scrolling up. Make sure we don't copy part of the mode
5222 line at the bottom. */
5223 if (from_y
+ run
->height
> bottom_y
)
5224 height
= bottom_y
- from_y
;
5226 height
= run
->height
;
5230 /* Scolling down. Make sure we don't copy over the mode line.
5232 if (to_y
+ run
->height
> bottom_y
)
5233 height
= bottom_y
- to_y
;
5235 height
= run
->height
;
5240 /* Cursor off. Will be switched on again in x_update_window_end. */
5244 XCopyArea (FRAME_X_DISPLAY (f
),
5245 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5246 f
->output_data
.x
->normal_gc
,
5256 /***********************************************************************
5258 ***********************************************************************/
5260 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5261 corner of the exposed rectangle. W and H are width and height of
5262 the exposed area. All are pixel values. W or H zero means redraw
5263 the entire frame. */
5266 expose_frame (f
, x
, y
, w
, h
)
5272 TRACE ((stderr
, "expose_frame "));
5274 /* No need to redraw if frame will be redrawn soon. */
5275 if (FRAME_GARBAGED_P (f
))
5277 TRACE ((stderr
, " garbaged\n"));
5281 /* If basic faces haven't been realized yet, there is no point in
5282 trying to redraw anything. This can happen when we get an expose
5283 event while Emacs is starting, e.g. by moving another window. */
5284 if (FRAME_FACE_CACHE (f
) == NULL
5285 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5287 TRACE ((stderr
, " no faces\n"));
5291 if (w
== 0 || h
== 0)
5294 r
.width
= CANON_X_UNIT (f
) * f
->width
;
5295 r
.height
= CANON_Y_UNIT (f
) * f
->height
;
5305 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
5306 expose_window_tree (XWINDOW (f
->root_window
), &r
);
5308 if (WINDOWP (f
->tool_bar_window
))
5310 struct window
*w
= XWINDOW (f
->tool_bar_window
);
5311 XRectangle window_rect
;
5312 XRectangle intersection_rect
;
5313 int window_x
, window_y
, window_width
, window_height
;
5316 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5317 window_rect
.x
= window_x
;
5318 window_rect
.y
= window_y
;
5319 window_rect
.width
= window_width
;
5320 window_rect
.height
= window_height
;
5322 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5323 expose_window (w
, &intersection_rect
);
5326 #ifndef USE_X_TOOLKIT
5327 if (WINDOWP (f
->menu_bar_window
))
5329 struct window
*w
= XWINDOW (f
->menu_bar_window
);
5330 XRectangle window_rect
;
5331 XRectangle intersection_rect
;
5332 int window_x
, window_y
, window_width
, window_height
;
5335 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5336 window_rect
.x
= window_x
;
5337 window_rect
.y
= window_y
;
5338 window_rect
.width
= window_width
;
5339 window_rect
.height
= window_height
;
5341 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5342 expose_window (w
, &intersection_rect
);
5344 #endif /* not USE_X_TOOLKIT */
5348 /* Redraw (parts) of all windows in the window tree rooted at W that
5349 intersect R. R contains frame pixel coordinates. */
5352 expose_window_tree (w
, r
)
5358 if (!NILP (w
->hchild
))
5359 expose_window_tree (XWINDOW (w
->hchild
), r
);
5360 else if (!NILP (w
->vchild
))
5361 expose_window_tree (XWINDOW (w
->vchild
), r
);
5364 XRectangle window_rect
;
5365 XRectangle intersection_rect
;
5366 struct frame
*f
= XFRAME (w
->frame
);
5367 int window_x
, window_y
, window_width
, window_height
;
5369 /* Frame-relative pixel rectangle of W. */
5370 window_box (w
, -1, &window_x
, &window_y
, &window_width
,
5374 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
5375 - FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5376 window_rect
.y
= window_y
;
5379 + FRAME_X_FLAGS_AREA_WIDTH (f
)
5380 + FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5382 = window_height
+ CURRENT_MODE_LINE_HEIGHT (w
);
5384 if (x_intersect_rectangles (r
, &window_rect
, &intersection_rect
))
5385 expose_window (w
, &intersection_rect
);
5388 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5393 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5394 which intersects rectangle R. R is in window-relative coordinates. */
5397 expose_area (w
, row
, r
, area
)
5399 struct glyph_row
*row
;
5401 enum glyph_row_area area
;
5404 struct glyph
*first
= row
->glyphs
[area
];
5405 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5409 /* Set x to the window-relative start position for drawing glyphs of
5410 AREA. The first glyph of the text area can be partially visible.
5411 The first glyphs of other areas cannot. */
5412 if (area
== LEFT_MARGIN_AREA
)
5414 else if (area
== TEXT_AREA
)
5415 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5417 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5418 + window_box_width (w
, TEXT_AREA
));
5420 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5421 /* If row extends face to end of line write the whole line. */
5422 x_draw_glyphs (w
, x
, row
, area
,
5424 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5428 /* Find the first glyph that must be redrawn. */
5430 && x
+ first
->pixel_width
< r
->x
)
5432 x
+= first
->pixel_width
;
5436 /* Find the last one. */
5440 && x
< r
->x
+ r
->width
)
5442 x
+= last
->pixel_width
;
5448 x_draw_glyphs (w
, first_x
, row
, area
,
5449 first
- row
->glyphs
[area
],
5450 last
- row
->glyphs
[area
],
5451 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5457 /* Redraw the parts of the glyph row ROW on window W intersecting
5458 rectangle R. R is in window-relative coordinates. */
5461 expose_line (w
, row
, r
)
5463 struct glyph_row
*row
;
5466 xassert (row
->enabled_p
);
5468 if (row
->mode_line_p
|| w
->pseudo_window_p
)
5469 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
5470 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5474 if (row
->used
[LEFT_MARGIN_AREA
])
5475 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
5476 if (row
->used
[TEXT_AREA
])
5477 expose_area (w
, row
, r
, TEXT_AREA
);
5478 if (row
->used
[RIGHT_MARGIN_AREA
])
5479 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
5480 x_draw_row_bitmaps (w
, row
);
5485 /* Return non-zero if W's cursor intersects rectangle R. */
5488 x_phys_cursor_in_rect_p (w
, r
)
5492 XRectangle cr
, result
;
5493 struct glyph
*cursor_glyph
;
5495 cursor_glyph
= get_phys_cursor_glyph (w
);
5498 cr
.x
= w
->phys_cursor
.x
;
5499 cr
.y
= w
->phys_cursor
.y
;
5500 cr
.width
= cursor_glyph
->pixel_width
;
5501 cr
.height
= w
->phys_cursor_height
;
5502 return x_intersect_rectangles (&cr
, r
, &result
);
5509 /* Redraw a rectangle of window W. R is a rectangle in window
5510 relative coordinates. Call this function with input blocked. */
5513 expose_window (w
, r
)
5517 struct glyph_row
*row
;
5519 int yb
= window_text_bottom_y (w
);
5520 int cursor_cleared_p
;
5522 /* If window is not yet fully initialized, do nothing. This can
5523 happen when toolkit scroll bars are used and a window is split.
5524 Reconfiguring the scroll bar will generate an expose for a newly
5526 if (w
->current_matrix
== NULL
)
5529 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
5530 r
->x
, r
->y
, r
->width
, r
->height
));
5532 /* Convert to window coordinates. */
5533 r
->x
= FRAME_TO_WINDOW_PIXEL_X (w
, r
->x
);
5534 r
->y
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
->y
);
5536 /* Turn off the cursor. */
5537 if (!w
->pseudo_window_p
5538 && x_phys_cursor_in_rect_p (w
, r
))
5541 cursor_cleared_p
= 1;
5544 cursor_cleared_p
= 0;
5546 /* Find the first row intersecting the rectangle R. */
5547 row
= w
->current_matrix
->rows
;
5549 while (row
->enabled_p
5551 && y
+ row
->height
< r
->y
)
5557 /* Display the text in the rectangle, one text line at a time. */
5558 while (row
->enabled_p
5560 && y
< r
->y
+ r
->height
)
5562 expose_line (w
, row
, r
);
5567 /* Display the mode line if there is one. */
5568 if (WINDOW_WANTS_MODELINE_P (w
)
5569 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
5571 && row
->y
< r
->y
+ r
->height
)
5572 expose_line (w
, row
, r
);
5574 if (!w
->pseudo_window_p
)
5576 /* Draw border between windows. */
5577 x_draw_vertical_border (w
);
5579 /* Turn the cursor on again. */
5580 if (cursor_cleared_p
)
5581 x_update_window_cursor (w
, 1);
5586 /* Determine the intersection of two rectangles R1 and R2. Return
5587 the intersection in *RESULT. Value is non-zero if RESULT is not
5591 x_intersect_rectangles (r1
, r2
, result
)
5592 XRectangle
*r1
, *r2
, *result
;
5594 XRectangle
*left
, *right
;
5595 XRectangle
*upper
, *lower
;
5596 int intersection_p
= 0;
5598 /* Rearrange so that R1 is the left-most rectangle. */
5600 left
= r1
, right
= r2
;
5602 left
= r2
, right
= r1
;
5604 /* X0 of the intersection is right.x0, if this is inside R1,
5605 otherwise there is no intersection. */
5606 if (right
->x
<= left
->x
+ left
->width
)
5608 result
->x
= right
->x
;
5610 /* The right end of the intersection is the minimum of the
5611 the right ends of left and right. */
5612 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
5615 /* Same game for Y. */
5617 upper
= r1
, lower
= r2
;
5619 upper
= r2
, lower
= r1
;
5621 /* The upper end of the intersection is lower.y0, if this is inside
5622 of upper. Otherwise, there is no intersection. */
5623 if (lower
->y
<= upper
->y
+ upper
->height
)
5625 result
->y
= lower
->y
;
5627 /* The lower end of the intersection is the minimum of the lower
5628 ends of upper and lower. */
5629 result
->height
= (min (lower
->y
+ lower
->height
,
5630 upper
->y
+ upper
->height
)
5636 return intersection_p
;
5647 /* We used to only do this if Vx_no_window_manager was non-nil, but
5648 the ICCCM (section 4.1.6) says that the window's border pixmap
5649 and border pixel are window attributes which are "private to the
5650 client", so we can always change it to whatever we want. */
5652 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5653 f
->output_data
.x
->border_pixel
);
5655 x_update_cursor (f
, 1);
5659 frame_unhighlight (f
)
5662 /* We used to only do this if Vx_no_window_manager was non-nil, but
5663 the ICCCM (section 4.1.6) says that the window's border pixmap
5664 and border pixel are window attributes which are "private to the
5665 client", so we can always change it to whatever we want. */
5667 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5668 f
->output_data
.x
->border_tile
);
5670 x_update_cursor (f
, 1);
5673 /* The focus has changed. Update the frames as necessary to reflect
5674 the new situation. Note that we can't change the selected frame
5675 here, because the Lisp code we are interrupting might become confused.
5676 Each event gets marked with the frame in which it occurred, so the
5677 Lisp code can tell when the switch took place by examining the events. */
5680 x_new_focus_frame (dpyinfo
, frame
)
5681 struct x_display_info
*dpyinfo
;
5682 struct frame
*frame
;
5684 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
5686 if (frame
!= dpyinfo
->x_focus_frame
)
5688 /* Set this before calling other routines, so that they see
5689 the correct value of x_focus_frame. */
5690 dpyinfo
->x_focus_frame
= frame
;
5692 if (old_focus
&& old_focus
->auto_lower
)
5693 x_lower_frame (old_focus
);
5696 selected_frame
= frame
;
5697 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
5699 Fselect_window (selected_frame
->selected_window
);
5700 choose_minibuf_frame ();
5703 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
5704 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
5706 pending_autoraise_frame
= 0;
5709 x_frame_rehighlight (dpyinfo
);
5712 /* Handle an event saying the mouse has moved out of an Emacs frame. */
5715 x_mouse_leave (dpyinfo
)
5716 struct x_display_info
*dpyinfo
;
5718 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
5721 /* The focus has changed, or we have redirected a frame's focus to
5722 another frame (this happens when a frame uses a surrogate
5723 mini-buffer frame). Shift the highlight as appropriate.
5725 The FRAME argument doesn't necessarily have anything to do with which
5726 frame is being highlighted or un-highlighted; we only use it to find
5727 the appropriate X display info. */
5730 XTframe_rehighlight (frame
)
5731 struct frame
*frame
;
5733 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
5737 x_frame_rehighlight (dpyinfo
)
5738 struct x_display_info
*dpyinfo
;
5740 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
5742 if (dpyinfo
->x_focus_frame
)
5744 dpyinfo
->x_highlight_frame
5745 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
5746 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
5747 : dpyinfo
->x_focus_frame
);
5748 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
5750 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
5751 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
5755 dpyinfo
->x_highlight_frame
= 0;
5757 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
5760 frame_unhighlight (old_highlight
);
5761 if (dpyinfo
->x_highlight_frame
)
5762 frame_highlight (dpyinfo
->x_highlight_frame
);
5768 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
5770 /* Initialize mode_switch_bit and modifier_meaning. */
5772 x_find_modifier_meanings (dpyinfo
)
5773 struct x_display_info
*dpyinfo
;
5775 int min_code
, max_code
;
5778 XModifierKeymap
*mods
;
5780 dpyinfo
->meta_mod_mask
= 0;
5781 dpyinfo
->shift_lock_mask
= 0;
5782 dpyinfo
->alt_mod_mask
= 0;
5783 dpyinfo
->super_mod_mask
= 0;
5784 dpyinfo
->hyper_mod_mask
= 0;
5787 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
5789 min_code
= dpyinfo
->display
->min_keycode
;
5790 max_code
= dpyinfo
->display
->max_keycode
;
5793 syms
= XGetKeyboardMapping (dpyinfo
->display
,
5794 min_code
, max_code
- min_code
+ 1,
5796 mods
= XGetModifierMapping (dpyinfo
->display
);
5798 /* Scan the modifier table to see which modifier bits the Meta and
5799 Alt keysyms are on. */
5801 int row
, col
; /* The row and column in the modifier table. */
5803 for (row
= 3; row
< 8; row
++)
5804 for (col
= 0; col
< mods
->max_keypermod
; col
++)
5807 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
5809 /* Zeroes are used for filler. Skip them. */
5813 /* Are any of this keycode's keysyms a meta key? */
5817 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
5819 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
5825 dpyinfo
->meta_mod_mask
|= (1 << row
);
5830 dpyinfo
->alt_mod_mask
|= (1 << row
);
5835 dpyinfo
->hyper_mod_mask
|= (1 << row
);
5840 dpyinfo
->super_mod_mask
|= (1 << row
);
5844 /* Ignore this if it's not on the lock modifier. */
5845 if ((1 << row
) == LockMask
)
5846 dpyinfo
->shift_lock_mask
= LockMask
;
5854 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
5855 if (! dpyinfo
->meta_mod_mask
)
5857 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
5858 dpyinfo
->alt_mod_mask
= 0;
5861 /* If some keys are both alt and meta,
5862 make them just meta, not alt. */
5863 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
5865 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
5868 XFree ((char *) syms
);
5869 XFreeModifiermap (mods
);
5872 /* Convert between the modifier bits X uses and the modifier bits
5876 x_x_to_emacs_modifiers (dpyinfo
, state
)
5877 struct x_display_info
*dpyinfo
;
5880 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
5881 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
5882 | ((state
& dpyinfo
->meta_mod_mask
) ? meta_modifier
: 0)
5883 | ((state
& dpyinfo
->alt_mod_mask
) ? alt_modifier
: 0)
5884 | ((state
& dpyinfo
->super_mod_mask
) ? super_modifier
: 0)
5885 | ((state
& dpyinfo
->hyper_mod_mask
) ? hyper_modifier
: 0));
5889 x_emacs_to_x_modifiers (dpyinfo
, state
)
5890 struct x_display_info
*dpyinfo
;
5893 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
5894 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
5895 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
5896 | ((state
& shift_modifier
) ? ShiftMask
: 0)
5897 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
5898 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
5901 /* Convert a keysym to its name. */
5904 x_get_keysym_name (keysym
)
5910 value
= XKeysymToString (keysym
);
5918 /* Mouse clicks and mouse movement. Rah. */
5920 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
5921 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
5922 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
5923 not force the value into range. */
5926 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
5928 register int pix_x
, pix_y
;
5929 register int *x
, *y
;
5933 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
5934 even for negative values. */
5936 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
5938 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
5940 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
5941 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
5945 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
5946 bounds
->height
= f
->output_data
.x
->line_height
;
5947 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
5948 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
5955 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
5956 pix_x
= FRAME_WINDOW_WIDTH (f
);
5960 else if (pix_y
> f
->height
)
5969 /* Given HPOS/VPOS in the current matrix of W, return corresponding
5970 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
5971 can't tell the positions because W's display is not up to date,
5975 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
5978 int *frame_x
, *frame_y
;
5982 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
5983 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
5985 if (display_completed
)
5987 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
5988 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
5989 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
5995 *frame_x
+= glyph
->pixel_width
;
6003 *frame_y
= *frame_x
= 0;
6007 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6008 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6013 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6015 If the event is a button press, then note that we have grabbed
6019 construct_mouse_click (result
, event
, f
)
6020 struct input_event
*result
;
6021 XButtonEvent
*event
;
6024 /* Make the event type no_event; we'll change that when we decide
6026 result
->kind
= mouse_click
;
6027 result
->code
= event
->button
- Button1
;
6028 result
->timestamp
= event
->time
;
6029 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6031 | (event
->type
== ButtonRelease
6035 XSETINT (result
->x
, event
->x
);
6036 XSETINT (result
->y
, event
->y
);
6037 XSETFRAME (result
->frame_or_window
, f
);
6041 #if 0 /* This function isn't called. --gerd */
6043 /* Prepare a menu-event in *RESULT for placement in the input queue. */
6046 construct_menu_click (result
, event
, f
)
6047 struct input_event
*result
;
6048 XButtonEvent
*event
;
6051 /* Make the event type no_event; we'll change that when we decide
6053 result
->kind
= mouse_click
;
6054 result
->code
= event
->button
- Button1
;
6055 result
->timestamp
= event
->time
;
6056 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6058 | (event
->type
== ButtonRelease
6062 XSETINT (result
->x
, event
->x
);
6063 XSETINT (result
->y
, -1);
6064 XSETFRAME (result
->frame_or_window
, f
);
6070 /* Function to report a mouse movement to the mainstream Emacs code.
6071 The input handler calls this.
6073 We have received a mouse movement event, which is given in *event.
6074 If the mouse is over a different glyph than it was last time, tell
6075 the mainstream emacs code by setting mouse_moved. If not, ask for
6076 another motion event, so we can check again the next time it moves. */
6078 static XMotionEvent last_mouse_motion_event
;
6079 static Lisp_Object last_mouse_motion_frame
;
6082 note_mouse_movement (frame
, event
)
6084 XMotionEvent
*event
;
6086 last_mouse_movement_time
= event
->time
;
6087 last_mouse_motion_event
= *event
;
6088 XSETFRAME (last_mouse_motion_frame
, frame
);
6090 if (event
->window
!= FRAME_X_WINDOW (frame
))
6092 frame
->mouse_moved
= 1;
6093 last_mouse_scroll_bar
= Qnil
;
6094 note_mouse_highlight (frame
, -1, -1);
6097 /* Has the mouse moved off the glyph it was on at the last sighting? */
6098 else if (event
->x
< last_mouse_glyph
.x
6099 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
6100 || event
->y
< last_mouse_glyph
.y
6101 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
6103 frame
->mouse_moved
= 1;
6104 last_mouse_scroll_bar
= Qnil
;
6105 note_mouse_highlight (frame
, event
->x
, event
->y
);
6109 /* This is used for debugging, to turn off note_mouse_highlight. */
6111 int disable_mouse_highlight
;
6115 /************************************************************************
6117 ************************************************************************/
6119 /* Find the glyph under window-relative coordinates X/Y in window W.
6120 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6121 strings. Return in *HPOS and *VPOS the row and column number of
6122 the glyph found. Return in *AREA the glyph area containing X.
6123 Value is a pointer to the glyph found or null if X/Y is not on
6124 text, or we can't tell because W's current matrix is not up to
6127 static struct glyph
*
6128 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
)
6131 int *hpos
, *vpos
, *area
;
6133 struct glyph
*glyph
, *end
;
6134 struct glyph_row
*row
;
6135 int x0
, i
, left_area_width
;
6137 /* Find row containing Y. Give up if some row is not enabled. */
6138 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6140 row
= MATRIX_ROW (w
->current_matrix
, i
);
6141 if (!row
->enabled_p
)
6143 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6150 /* Give up if Y is not in the window. */
6151 if (i
== w
->current_matrix
->nrows
)
6154 /* Get the glyph area containing X. */
6155 if (w
->pseudo_window_p
)
6162 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6163 if (x
< left_area_width
)
6165 *area
= LEFT_MARGIN_AREA
;
6168 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6171 x0
= row
->x
+ left_area_width
;
6175 *area
= RIGHT_MARGIN_AREA
;
6176 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6180 /* Find glyph containing X. */
6181 glyph
= row
->glyphs
[*area
];
6182 end
= glyph
+ row
->used
[*area
];
6185 if (x
< x0
+ glyph
->pixel_width
)
6187 if (w
->pseudo_window_p
)
6189 else if (BUFFERP (glyph
->object
))
6193 x0
+= glyph
->pixel_width
;
6200 *hpos
= glyph
- row
->glyphs
[*area
];
6205 /* Convert frame-relative x/y to coordinates relative to window W.
6206 Takes pseudo-windows into account. */
6209 frame_to_window_pixel_xy (w
, x
, y
)
6213 if (w
->pseudo_window_p
)
6215 /* A pseudo-window is always full-width, and starts at the
6216 left edge of the frame, plus a frame border. */
6217 struct frame
*f
= XFRAME (w
->frame
);
6218 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6219 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6223 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6224 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6229 /* Take proper action when mouse has moved to the mode or top line of
6230 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6231 mode line. X is relative to the start of the text display area of
6232 W, so the width of bitmap areas and scroll bars must be subtracted
6233 to get a position relative to the start of the mode line. */
6236 note_mode_line_highlight (w
, x
, mode_line_p
)
6240 struct frame
*f
= XFRAME (w
->frame
);
6241 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6242 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6243 struct glyph_row
*row
;
6246 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6248 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6252 struct glyph
*glyph
, *end
;
6253 Lisp_Object help
, map
;
6256 /* Find the glyph under X. */
6257 glyph
= row
->glyphs
[TEXT_AREA
];
6258 end
= glyph
+ row
->used
[TEXT_AREA
];
6259 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6260 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
));
6262 && x
>= x0
+ glyph
->pixel_width
)
6264 x0
+= glyph
->pixel_width
;
6269 && STRINGP (glyph
->object
)
6270 && XSTRING (glyph
->object
)->intervals
6271 && glyph
->charpos
>= 0
6272 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6274 /* If we're on a string with `help-echo' text property,
6275 arrange for the help to be displayed. This is done by
6276 setting the global variable help_echo to the help string. */
6277 help
= Fget_text_property (make_number (glyph
->charpos
),
6278 Qhelp_echo
, glyph
->object
);
6282 /* Change the mouse pointer according to what is under X/Y. */
6283 map
= Fget_text_property (make_number (glyph
->charpos
),
6284 Qlocal_map
, glyph
->object
);
6285 if (!NILP (Fkeymapp (map
)))
6286 cursor
= f
->output_data
.x
->nontext_cursor
;
6290 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6294 /* Take proper action when the mouse has moved to position X, Y on
6295 frame F as regards highlighting characters that have mouse-face
6296 properties. Also de-highlighting chars where the mouse was before.
6297 X and Y can be negative or out of range. */
6300 note_mouse_highlight (f
, x
, y
)
6304 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6309 /* When a menu is active, don't highlight because this looks odd. */
6310 #ifdef USE_X_TOOLKIT
6311 if (popup_activated ())
6315 if (disable_mouse_highlight
6316 || !f
->glyphs_initialized_p
)
6319 dpyinfo
->mouse_face_mouse_x
= x
;
6320 dpyinfo
->mouse_face_mouse_y
= y
;
6321 dpyinfo
->mouse_face_mouse_frame
= f
;
6323 if (dpyinfo
->mouse_face_defer
)
6328 dpyinfo
->mouse_face_deferred_gc
= 1;
6332 /* Which window is that in? */
6333 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6335 /* If we were displaying active text in another window, clear that. */
6336 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6337 clear_mouse_face (dpyinfo
);
6339 /* Not on a window -> return. */
6340 if (!WINDOWP (window
))
6343 /* Convert to window-relative pixel coordinates. */
6344 w
= XWINDOW (window
);
6345 frame_to_window_pixel_xy (w
, &x
, &y
);
6347 /* Handle tool-bar window differently since it doesn't display a
6349 if (EQ (window
, f
->tool_bar_window
))
6351 note_tool_bar_highlight (f
, x
, y
);
6355 if (portion
== 1 || portion
== 3)
6357 /* Mouse is on the mode or top line. */
6358 note_mode_line_highlight (w
, x
, portion
== 1);
6362 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6363 f
->output_data
.x
->text_cursor
);
6365 /* Are we in a window whose display is up to date?
6366 And verify the buffer's text has not changed. */
6367 if (/* Within text portion of the window. */
6369 && EQ (w
->window_end_valid
, w
->buffer
)
6370 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
6371 && (XFASTINT (w
->last_overlay_modified
)
6372 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
6374 int hpos
, vpos
, pos
, i
, area
;
6375 struct glyph
*glyph
;
6377 /* Find the glyph under X/Y. */
6378 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
);
6380 /* Clear mouse face if X/Y not over text. */
6382 || area
!= TEXT_AREA
6383 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6385 clear_mouse_face (dpyinfo
);
6389 pos
= glyph
->charpos
;
6390 xassert (w
->pseudo_window_p
|| BUFFERP (glyph
->object
));
6392 /* Check for mouse-face and help-echo. */
6394 Lisp_Object mouse_face
, overlay
, position
;
6395 Lisp_Object
*overlay_vec
;
6397 struct buffer
*obuf
;
6400 /* If we get an out-of-range value, return now; avoid an error. */
6401 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
6404 /* Make the window's buffer temporarily current for
6405 overlays_at and compute_char_face. */
6406 obuf
= current_buffer
;
6407 current_buffer
= XBUFFER (w
->buffer
);
6413 /* Is this char mouse-active or does it have help-echo? */
6414 XSETINT (position
, pos
);
6416 /* Put all the overlays we want in a vector in overlay_vec.
6417 Store the length in len. If there are more than 10, make
6418 enough space for all, and try again. */
6420 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6421 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
6422 if (noverlays
> len
)
6425 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6426 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
6429 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6431 /* Check mouse-face highlighting. */
6432 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
6433 && vpos
>= dpyinfo
->mouse_face_beg_row
6434 && vpos
<= dpyinfo
->mouse_face_end_row
6435 && (vpos
> dpyinfo
->mouse_face_beg_row
6436 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6437 && (vpos
< dpyinfo
->mouse_face_end_row
6438 || hpos
< dpyinfo
->mouse_face_end_col
6439 || dpyinfo
->mouse_face_past_end
)))
6441 /* Clear the display of the old active region, if any. */
6442 clear_mouse_face (dpyinfo
);
6444 /* Find the highest priority overlay that has a mouse-face prop. */
6446 for (i
= 0; i
< noverlays
; i
++)
6448 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
6449 if (!NILP (mouse_face
))
6451 overlay
= overlay_vec
[i
];
6456 /* If no overlay applies, get a text property. */
6458 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
6460 /* Handle the overlay case. */
6461 if (! NILP (overlay
))
6463 /* Find the range of text around this char that
6464 should be active. */
6465 Lisp_Object before
, after
;
6468 before
= Foverlay_start (overlay
);
6469 after
= Foverlay_end (overlay
);
6470 /* Record this as the current active region. */
6471 fast_find_position (w
, XFASTINT (before
),
6472 &dpyinfo
->mouse_face_beg_col
,
6473 &dpyinfo
->mouse_face_beg_row
,
6474 &dpyinfo
->mouse_face_beg_x
,
6475 &dpyinfo
->mouse_face_beg_y
);
6476 dpyinfo
->mouse_face_past_end
6477 = !fast_find_position (w
, XFASTINT (after
),
6478 &dpyinfo
->mouse_face_end_col
,
6479 &dpyinfo
->mouse_face_end_row
,
6480 &dpyinfo
->mouse_face_end_x
,
6481 &dpyinfo
->mouse_face_end_y
);
6482 dpyinfo
->mouse_face_window
= window
;
6483 dpyinfo
->mouse_face_face_id
6484 = face_at_buffer_position (w
, pos
, 0, 0,
6485 &ignore
, pos
+ 1, 1);
6487 /* Display it as active. */
6488 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6490 /* Handle the text property case. */
6491 else if (! NILP (mouse_face
))
6493 /* Find the range of text around this char that
6494 should be active. */
6495 Lisp_Object before
, after
, beginning
, end
;
6498 beginning
= Fmarker_position (w
->start
);
6499 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
6500 - XFASTINT (w
->window_end_pos
)));
6502 = Fprevious_single_property_change (make_number (pos
+ 1),
6504 w
->buffer
, beginning
);
6506 = Fnext_single_property_change (position
, Qmouse_face
,
6508 /* Record this as the current active region. */
6509 fast_find_position (w
, XFASTINT (before
),
6510 &dpyinfo
->mouse_face_beg_col
,
6511 &dpyinfo
->mouse_face_beg_row
,
6512 &dpyinfo
->mouse_face_beg_x
,
6513 &dpyinfo
->mouse_face_beg_y
);
6514 dpyinfo
->mouse_face_past_end
6515 = !fast_find_position (w
, XFASTINT (after
),
6516 &dpyinfo
->mouse_face_end_col
,
6517 &dpyinfo
->mouse_face_end_row
,
6518 &dpyinfo
->mouse_face_end_x
,
6519 &dpyinfo
->mouse_face_end_y
);
6520 dpyinfo
->mouse_face_window
= window
;
6521 dpyinfo
->mouse_face_face_id
6522 = face_at_buffer_position (w
, pos
, 0, 0,
6523 &ignore
, pos
+ 1, 1);
6525 /* Display it as active. */
6526 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6530 /* Look for a `help-echo' property. */
6534 /* Check overlays first. */
6536 for (i
= 0; i
< noverlays
&& !STRINGP (help
); ++i
)
6537 help
= Foverlay_get (overlay_vec
[i
], Qhelp_echo
);
6539 /* Try text properties. */
6541 && ((STRINGP (glyph
->object
)
6542 && glyph
->charpos
>= 0
6543 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6544 || (BUFFERP (glyph
->object
)
6545 && glyph
->charpos
>= BEGV
6546 && glyph
->charpos
< ZV
)))
6547 help
= Fget_text_property (make_number (glyph
->charpos
),
6548 Qhelp_echo
, glyph
->object
);
6556 current_buffer
= obuf
;
6562 redo_mouse_highlight ()
6564 if (!NILP (last_mouse_motion_frame
)
6565 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
6566 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
6567 last_mouse_motion_event
.x
,
6568 last_mouse_motion_event
.y
);
6573 /***********************************************************************
6575 ***********************************************************************/
6577 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
6578 struct glyph
**, int *, int *, int *));
6580 /* Tool-bar item index of the item on which a mouse button was pressed
6583 static int last_tool_bar_item
;
6586 /* Get information about the tool-bar item at position X/Y on frame F.
6587 Return in *GLYPH a pointer to the glyph of the tool-bar item in
6588 the current matrix of the tool-bar window of F, or NULL if not
6589 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
6590 item in F->current_tool_bar_items. Value is
6592 -1 if X/Y is not on a tool-bar item
6593 0 if X/Y is on the same item that was highlighted before.
6597 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
6600 struct glyph
**glyph
;
6601 int *hpos
, *vpos
, *prop_idx
;
6603 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6604 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6607 /* Find the glyph under X/Y. */
6608 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
);
6612 /* Get the start of this tool-bar item's properties in
6613 f->current_tool_bar_items. */
6614 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
6617 /* Is mouse on the highlighted item? */
6618 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
6619 && *vpos
>= dpyinfo
->mouse_face_beg_row
6620 && *vpos
<= dpyinfo
->mouse_face_end_row
6621 && (*vpos
> dpyinfo
->mouse_face_beg_row
6622 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
6623 && (*vpos
< dpyinfo
->mouse_face_end_row
6624 || *hpos
< dpyinfo
->mouse_face_end_col
6625 || dpyinfo
->mouse_face_past_end
))
6632 /* Handle mouse button event on the tool-bar of frame F, at
6633 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
6637 x_handle_tool_bar_click (f
, button_event
)
6639 XButtonEvent
*button_event
;
6641 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6642 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6643 int hpos
, vpos
, prop_idx
;
6644 struct glyph
*glyph
;
6645 Lisp_Object enabled_p
;
6646 int x
= button_event
->x
;
6647 int y
= button_event
->y
;
6649 /* If not on the highlighted tool-bar item, return. */
6650 frame_to_window_pixel_xy (w
, &x
, &y
);
6651 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
6654 /* If item is disabled, do nothing. */
6655 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
6656 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
6657 if (NILP (enabled_p
))
6660 if (button_event
->type
== ButtonPress
)
6662 /* Show item in pressed state. */
6663 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
6664 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
6665 last_tool_bar_item
= prop_idx
;
6669 Lisp_Object key
, frame
;
6670 struct input_event event
;
6672 /* Show item in released state. */
6673 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
6674 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
6676 key
= (XVECTOR (f
->current_tool_bar_items
)
6677 ->contents
[prop_idx
+ TOOL_BAR_ITEM_KEY
]);
6679 XSETFRAME (frame
, f
);
6680 event
.kind
= TOOL_BAR_EVENT
;
6681 event
.frame_or_window
= Fcons (frame
, Fcons (Qtool_bar
, Qnil
));
6682 kbd_buffer_store_event (&event
);
6684 event
.kind
= TOOL_BAR_EVENT
;
6685 event
.frame_or_window
= Fcons (frame
, key
);
6686 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6687 button_event
->state
);
6688 kbd_buffer_store_event (&event
);
6689 last_tool_bar_item
= -1;
6694 /* Possibly highlight a tool-bar item on frame F when mouse moves to
6695 tool-bar window-relative coordinates X/Y. Called from
6696 note_mouse_highlight. */
6699 note_tool_bar_highlight (f
, x
, y
)
6703 Lisp_Object window
= f
->tool_bar_window
;
6704 struct window
*w
= XWINDOW (window
);
6705 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6707 struct glyph
*glyph
;
6708 struct glyph_row
*row
;
6710 Lisp_Object enabled_p
;
6712 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
6713 int mouse_down_p
, rc
;
6715 /* Function note_mouse_highlight is called with negative x(y
6716 values when mouse moves outside of the frame. */
6717 if (x
<= 0 || y
<= 0)
6719 clear_mouse_face (dpyinfo
);
6723 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
6726 /* Not on tool-bar item. */
6727 clear_mouse_face (dpyinfo
);
6731 /* On same tool-bar item as before. */
6734 clear_mouse_face (dpyinfo
);
6736 /* Mouse is down, but on different tool-bar item? */
6737 mouse_down_p
= (dpyinfo
->grabbed
6738 && f
== last_mouse_frame
6739 && FRAME_LIVE_P (f
));
6741 && last_tool_bar_item
!= prop_idx
)
6744 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
6745 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
6747 /* If tool-bar item is not enabled, don't highlight it. */
6748 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
6749 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
6750 if (!NILP (enabled_p
))
6752 /* Compute the x-position of the glyph. In front and past the
6753 image is a space. We include this is the highlighted area. */
6754 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6755 for (i
= x
= 0; i
< hpos
; ++i
)
6756 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
6758 /* Record this as the current active region. */
6759 dpyinfo
->mouse_face_beg_col
= hpos
;
6760 dpyinfo
->mouse_face_beg_row
= vpos
;
6761 dpyinfo
->mouse_face_beg_x
= x
;
6762 dpyinfo
->mouse_face_beg_y
= row
->y
;
6763 dpyinfo
->mouse_face_past_end
= 0;
6765 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
6766 dpyinfo
->mouse_face_end_row
= vpos
;
6767 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
6768 dpyinfo
->mouse_face_end_y
= row
->y
;
6769 dpyinfo
->mouse_face_window
= window
;
6770 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
6772 /* Display it as active. */
6773 show_mouse_face (dpyinfo
, draw
);
6774 dpyinfo
->mouse_face_image_state
= draw
;
6779 /* Set help_echo to a help string.to display for this tool-bar item.
6780 XTread_socket does the rest. */
6781 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
6782 ->contents
[prop_idx
+ TOOL_BAR_ITEM_HELP
]);
6783 if (!STRINGP (help_echo
))
6784 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
6785 ->contents
[prop_idx
+ TOOL_BAR_ITEM_CAPTION
]);
6790 /* Find the glyph matrix position of buffer position POS in window W.
6791 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
6792 current glyphs must be up to date. If POS is above window start
6793 return (0, 0, 0, 0). If POS is after end of W, return end of
6797 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
)
6800 int *hpos
, *vpos
, *x
, *y
;
6804 int maybe_next_line_p
= 0;
6805 int line_start_position
;
6806 int yb
= window_text_bottom_y (w
);
6807 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
6808 struct glyph_row
*best_row
= row
;
6809 int row_vpos
= 0, best_row_vpos
= 0;
6814 if (row
->used
[TEXT_AREA
])
6815 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
6817 line_start_position
= 0;
6819 if (line_start_position
> pos
)
6821 /* If the position sought is the end of the buffer,
6822 don't include the blank lines at the bottom of the window. */
6823 else if (line_start_position
== pos
6824 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
6826 maybe_next_line_p
= 1;
6829 else if (line_start_position
> 0)
6832 best_row_vpos
= row_vpos
;
6835 if (row
->y
+ row
->height
>= yb
)
6842 /* Find the right column within BEST_ROW. */
6844 current_x
= best_row
->x
;
6845 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
6847 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
6850 charpos
= glyph
->charpos
;
6854 *vpos
= best_row_vpos
;
6859 else if (charpos
> pos
)
6861 else if (charpos
> 0)
6864 current_x
+= glyph
->pixel_width
;
6867 /* If we're looking for the end of the buffer,
6868 and we didn't find it in the line we scanned,
6869 use the start of the following line. */
6870 if (maybe_next_line_p
)
6875 current_x
= best_row
->x
;
6878 *vpos
= best_row_vpos
;
6879 *hpos
= lastcol
+ 1;
6886 /* Display the active region described by mouse_face_*
6887 in its mouse-face if HL > 0, in its normal face if HL = 0. */
6890 show_mouse_face (dpyinfo
, draw
)
6891 struct x_display_info
*dpyinfo
;
6892 enum draw_glyphs_face draw
;
6894 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
6895 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
6897 int cursor_off_p
= 0;
6898 struct cursor_pos saved_cursor
;
6900 saved_cursor
= output_cursor
;
6902 /* If window is in the process of being destroyed, don't bother
6904 if (w
->current_matrix
== NULL
)
6907 /* Recognize when we are called to operate on rows that don't exist
6908 anymore. This can happen when a window is split. */
6909 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
6912 set_output_cursor (&w
->phys_cursor
);
6914 /* Note that mouse_face_beg_row etc. are window relative. */
6915 for (i
= dpyinfo
->mouse_face_beg_row
;
6916 i
<= dpyinfo
->mouse_face_end_row
;
6919 int start_hpos
, end_hpos
, start_x
;
6920 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
6922 /* Don't do anything if row doesn't have valid contents. */
6923 if (!row
->enabled_p
)
6926 /* For all but the first row, the highlight starts at column 0. */
6927 if (i
== dpyinfo
->mouse_face_beg_row
)
6929 start_hpos
= dpyinfo
->mouse_face_beg_col
;
6930 start_x
= dpyinfo
->mouse_face_beg_x
;
6938 if (i
== dpyinfo
->mouse_face_end_row
)
6939 end_hpos
= dpyinfo
->mouse_face_end_col
;
6941 end_hpos
= row
->used
[TEXT_AREA
];
6943 /* If the cursor's in the text we are about to rewrite, turn the
6945 if (!w
->pseudo_window_p
6946 && i
== output_cursor
.vpos
6947 && output_cursor
.hpos
>= start_hpos
- 1
6948 && output_cursor
.hpos
<= end_hpos
)
6950 x_update_window_cursor (w
, 0);
6954 if (end_hpos
> start_hpos
)
6955 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
6956 start_hpos
, end_hpos
, draw
, NULL
, NULL
, 0);
6959 /* If we turned the cursor off, turn it back on. */
6961 x_display_cursor (w
, 1,
6962 output_cursor
.hpos
, output_cursor
.vpos
,
6963 output_cursor
.x
, output_cursor
.y
);
6965 output_cursor
= saved_cursor
;
6969 /* Change the mouse cursor. */
6970 if (draw
== DRAW_NORMAL_TEXT
)
6971 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6972 f
->output_data
.x
->text_cursor
);
6973 else if (draw
== DRAW_MOUSE_FACE
)
6974 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6975 f
->output_data
.x
->cross_cursor
);
6977 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6978 f
->output_data
.x
->nontext_cursor
);
6981 /* Clear out the mouse-highlighted active region.
6982 Redraw it un-highlighted first. */
6985 clear_mouse_face (dpyinfo
)
6986 struct x_display_info
*dpyinfo
;
6991 if (! NILP (dpyinfo
->mouse_face_window
))
6992 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
6994 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6995 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6996 dpyinfo
->mouse_face_window
= Qnil
;
6999 /* Just discard the mouse face information for frame F, if any.
7000 This is used when the size of F is changed. */
7003 cancel_mouse_face (f
)
7007 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7009 window
= dpyinfo
->mouse_face_window
;
7010 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7012 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7013 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7014 dpyinfo
->mouse_face_window
= Qnil
;
7018 static struct scroll_bar
*x_window_to_scroll_bar ();
7019 static void x_scroll_bar_report_motion ();
7021 /* Return the current position of the mouse.
7022 *fp should be a frame which indicates which display to ask about.
7024 If the mouse movement started in a scroll bar, set *fp, *bar_window,
7025 and *part to the frame, window, and scroll bar part that the mouse
7026 is over. Set *x and *y to the portion and whole of the mouse's
7027 position on the scroll bar.
7029 If the mouse movement started elsewhere, set *fp to the frame the
7030 mouse is on, *bar_window to nil, and *x and *y to the character cell
7033 Set *time to the server time-stamp for the time at which the mouse
7034 was at this position.
7036 Don't store anything if we don't have a valid set of values to report.
7038 This clears the mouse_moved flag, so we can wait for the next mouse
7042 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7045 Lisp_Object
*bar_window
;
7046 enum scroll_bar_part
*part
;
7048 unsigned long *time
;
7054 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7055 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7061 Window dummy_window
;
7064 Lisp_Object frame
, tail
;
7066 /* Clear the mouse-moved flag for every frame on this display. */
7067 FOR_EACH_FRAME (tail
, frame
)
7068 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
7069 XFRAME (frame
)->mouse_moved
= 0;
7071 last_mouse_scroll_bar
= Qnil
;
7073 /* Figure out which root window we're on. */
7074 XQueryPointer (FRAME_X_DISPLAY (*fp
),
7075 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
7077 /* The root window which contains the pointer. */
7080 /* Trash which we can't trust if the pointer is on
7081 a different screen. */
7084 /* The position on that root window. */
7087 /* More trash we can't trust. */
7090 /* Modifier keys and pointer buttons, about which
7092 (unsigned int *) &dummy
);
7094 /* Now we have a position on the root; find the innermost window
7095 containing the pointer. */
7099 int parent_x
= 0, parent_y
= 0;
7104 /* XTranslateCoordinates can get errors if the window
7105 structure is changing at the same time this function
7106 is running. So at least we must not crash from them. */
7108 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
7110 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
7111 && FRAME_LIVE_P (last_mouse_frame
))
7113 /* If mouse was grabbed on a frame, give coords for that frame
7114 even if the mouse is now outside it. */
7115 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7117 /* From-window, to-window. */
7118 root
, FRAME_X_WINDOW (last_mouse_frame
),
7120 /* From-position, to-position. */
7121 root_x
, root_y
, &win_x
, &win_y
,
7125 f1
= last_mouse_frame
;
7131 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7133 /* From-window, to-window. */
7136 /* From-position, to-position. */
7137 root_x
, root_y
, &win_x
, &win_y
,
7142 if (child
== None
|| child
== win
)
7150 /* Now we know that:
7151 win is the innermost window containing the pointer
7152 (XTC says it has no child containing the pointer),
7153 win_x and win_y are the pointer's position in it
7154 (XTC did this the last time through), and
7155 parent_x and parent_y are the pointer's position in win's parent.
7156 (They are what win_x and win_y were when win was child.
7157 If win is the root window, it has no parent, and
7158 parent_{x,y} are invalid, but that's okay, because we'll
7159 never use them in that case.) */
7161 /* Is win one of our frames? */
7162 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
7165 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
7168 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
7170 /* If not, is it one of our scroll bars? */
7173 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
7177 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7183 if (f1
== 0 && insist
> 0)
7184 f1
= SELECTED_FRAME ();
7188 /* Ok, we found a frame. Store all the values.
7189 last_mouse_glyph is a rectangle used to reduce the
7190 generation of mouse events. To not miss any motion
7191 events, we must divide the frame into rectangles of the
7192 size of the smallest character that could be displayed
7193 on it, i.e. into the same rectangles that matrices on
7194 the frame are divided into. */
7196 #if OLD_REDISPLAY_CODE
7197 int ignore1
, ignore2
;
7198 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
7200 FRAME_X_DISPLAY_INFO (f1
)->grabbed
7204 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
7205 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
7209 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7210 round down even for negative values. */
7216 last_mouse_glyph
.width
= width
;
7217 last_mouse_glyph
.height
= height
;
7218 last_mouse_glyph
.x
= (x
+ width
- 1) / width
* width
;
7219 last_mouse_glyph
.y
= (y
+ height
- 1) / height
* height
;
7226 XSETINT (*x
, win_x
);
7227 XSETINT (*y
, win_y
);
7228 *time
= last_mouse_movement_time
;
7237 #ifdef USE_X_TOOLKIT
7239 /* Atimer callback function for TIMER. Called every 0.1s to process
7240 Xt timeouts, if needed. We must avoid calling XtAppPending as
7241 much as possible because that function does an implicit XFlush
7242 that slows us down. */
7245 x_process_timeouts (timer
)
7246 struct atimer
*timer
;
7248 if (toolkit_scroll_bar_interaction
|| popup_activated_flag
)
7251 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
7252 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
7257 #endif /* USE_X_TOOLKIT */
7260 /* Scroll bar support. */
7262 /* Given an X window ID, find the struct scroll_bar which manages it.
7263 This can be called in GC, so we have to make sure to strip off mark
7266 static struct scroll_bar
*
7267 x_window_to_scroll_bar (window_id
)
7272 for (tail
= Vframe_list
;
7273 XGCTYPE (tail
) == Lisp_Cons
;
7276 Lisp_Object frame
, bar
, condemned
;
7278 frame
= XCAR (tail
);
7279 /* All elements of Vframe_list should be frames. */
7280 if (! GC_FRAMEP (frame
))
7283 /* Scan this frame's scroll bar list for a scroll bar with the
7285 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
7286 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
7287 /* This trick allows us to search both the ordinary and
7288 condemned scroll bar lists with one loop. */
7289 ! GC_NILP (bar
) || (bar
= condemned
,
7292 bar
= XSCROLL_BAR (bar
)->next
)
7293 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
7294 return XSCROLL_BAR (bar
);
7302 /************************************************************************
7304 ************************************************************************/
7306 #if USE_TOOLKIT_SCROLL_BARS
7308 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
7309 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
7310 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
7311 struct scroll_bar
*));
7312 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
7316 /* Id of action hook installed for scroll bars. */
7318 static XtActionHookId action_hook_id
;
7320 /* Lisp window being scrolled. Set when starting to interact with
7321 a toolkit scroll bar, reset to nil when ending the interaction. */
7323 static Lisp_Object window_being_scrolled
;
7325 /* Last scroll bar part sent in xm_scroll_callback. */
7327 static int last_scroll_bar_part
;
7329 /* Whether this is an Xaw with arrow-scrollbars. This should imply
7330 that movements of 1/20 of the screen size are mapped to up/down. */
7332 static Boolean xaw3d_arrow_scroll
;
7334 /* Whether the drag scrolling maintains the mouse at the top of the
7335 thumb. If not, resizing the thumb needs to be done more carefully
7336 to avoid jerkyness. */
7338 static Boolean xaw3d_pick_top
;
7341 /* Action hook installed via XtAppAddActionHook when toolkit scroll
7342 bars are used.. The hook is responsible for detecting when
7343 the user ends an interaction with the scroll bar, and generates
7344 a `end-scroll' scroll_bar_click' event if so. */
7347 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
7350 XtPointer client_data
;
7354 Cardinal
*num_params
;
7360 scroll_bar_p
= XmIsScrollBar (widget
);
7361 end_action
= "Release";
7362 #else /* !USE_MOTIF i.e. use Xaw */
7363 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
7364 end_action
= "EndScroll";
7365 #endif /* USE_MOTIF */
7368 && strcmp (action_name
, end_action
) == 0
7369 && WINDOWP (window_being_scrolled
))
7373 x_send_scroll_bar_event (window_being_scrolled
,
7374 scroll_bar_end_scroll
, 0, 0);
7375 w
= XWINDOW (window_being_scrolled
);
7376 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
7377 window_being_scrolled
= Qnil
;
7378 last_scroll_bar_part
= -1;
7380 /* Xt timeouts no longer needed. */
7381 toolkit_scroll_bar_interaction
= 0;
7386 /* Send a client message with message type Xatom_Scrollbar for a
7387 scroll action to the frame of WINDOW. PART is a value identifying
7388 the part of the scroll bar that was clicked on. PORTION is the
7389 amount to scroll of a whole of WHOLE. */
7392 x_send_scroll_bar_event (window
, part
, portion
, whole
)
7394 int part
, portion
, whole
;
7397 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
7398 struct frame
*f
= XFRAME (XWINDOW (window
)->frame
);
7400 /* Construct a ClientMessage event to send to the frame. */
7401 ev
->type
= ClientMessage
;
7402 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
7403 ev
->display
= FRAME_X_DISPLAY (f
);
7404 ev
->window
= FRAME_X_WINDOW (f
);
7406 ev
->data
.l
[0] = (long) window
;
7407 ev
->data
.l
[1] = (long) part
;
7408 ev
->data
.l
[2] = (long) 0;
7409 ev
->data
.l
[3] = (long) portion
;
7410 ev
->data
.l
[4] = (long) whole
;
7412 /* Make Xt timeouts work while the scroll bar is active. */
7413 toolkit_scroll_bar_interaction
= 1;
7415 /* Setting the event mask to zero means that the message will
7416 be sent to the client that created the window, and if that
7417 window no longer exists, no event will be sent. */
7419 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
7424 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
7428 x_scroll_bar_to_input_event (event
, ievent
)
7430 struct input_event
*ievent
;
7432 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
7433 Lisp_Object window
= (Lisp_Object
) ev
->data
.l
[0];
7434 struct frame
*f
= XFRAME (XWINDOW (window
)->frame
);
7436 ievent
->kind
= scroll_bar_click
;
7437 ievent
->frame_or_window
= window
;
7438 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
7439 ievent
->part
= ev
->data
.l
[1];
7440 ievent
->code
= ev
->data
.l
[2];
7441 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
7442 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
7443 ievent
->modifiers
= 0;
7449 /* Minimum and maximum values used for Motif scroll bars. */
7452 #define XM_SB_MAX 10000000
7453 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
7456 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
7457 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
7458 CALL_DATA is a pointer a a XmScrollBarCallbackStruct. */
7461 xm_scroll_callback (widget
, client_data
, call_data
)
7463 XtPointer client_data
, call_data
;
7465 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7466 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
7468 int part
= -1, whole
= 0, portion
= 0;
7472 case XmCR_DECREMENT
:
7473 bar
->dragging
= Qnil
;
7474 part
= scroll_bar_up_arrow
;
7477 case XmCR_INCREMENT
:
7478 bar
->dragging
= Qnil
;
7479 part
= scroll_bar_down_arrow
;
7482 case XmCR_PAGE_DECREMENT
:
7483 bar
->dragging
= Qnil
;
7484 part
= scroll_bar_above_handle
;
7487 case XmCR_PAGE_INCREMENT
:
7488 bar
->dragging
= Qnil
;
7489 part
= scroll_bar_below_handle
;
7493 bar
->dragging
= Qnil
;
7494 part
= scroll_bar_to_top
;
7497 case XmCR_TO_BOTTOM
:
7498 bar
->dragging
= Qnil
;
7499 part
= scroll_bar_to_bottom
;
7505 int dragging_down_p
= (INTEGERP (bar
->dragging
)
7506 && XINT (bar
->dragging
) <= cs
->value
);
7508 /* Get the slider size. */
7510 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
7513 /* At the max position of the scroll bar, do a line-wise
7514 movement. Without doing anything, the LessTif scroll bar
7515 calls us with the same cs->value again and again. If we
7516 want to make sure that we can reach the end of the buffer,
7517 we have to do something.
7519 Implementation note: setting bar->dragging always to
7520 cs->value gives a smoother movement at the max position.
7521 Setting it to nil when doing line-wise movement gives
7522 a better slider behavior. */
7524 if (cs
->value
+ slider_size
== XM_SB_MAX
7526 && last_scroll_bar_part
== scroll_bar_down_arrow
))
7528 part
= scroll_bar_down_arrow
;
7529 bar
->dragging
= Qnil
;
7533 whole
= XM_SB_RANGE
;
7534 portion
= min (cs
->value
- XM_SB_MIN
, XM_SB_MAX
- slider_size
);
7535 part
= scroll_bar_handle
;
7536 bar
->dragging
= make_number (cs
->value
);
7541 case XmCR_VALUE_CHANGED
:
7547 window_being_scrolled
= bar
->window
;
7548 last_scroll_bar_part
= part
;
7549 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
7554 #else /* !USE_MOTIF, i.e. Xaw. */
7557 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
7558 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
7559 scroll bar struct. CALL_DATA is a pointer to a float saying where
7563 xaw_jump_callback (widget
, client_data
, call_data
)
7565 XtPointer client_data
, call_data
;
7567 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7568 float top
= *(float *) call_data
;
7570 int whole
, portion
, height
;
7573 /* Get the size of the thumb, a value between 0 and 1. */
7575 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
7579 portion
= shown
< 1 ? top
* whole
: 0;
7581 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
7582 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
7583 the bottom, so we force the scrolling whenever we see that we're
7584 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
7585 we try to ensure that we always stay two pixels away from the
7587 part
= scroll_bar_down_arrow
;
7589 part
= scroll_bar_handle
;
7591 window_being_scrolled
= bar
->window
;
7592 bar
->dragging
= make_number (portion
);
7593 last_scroll_bar_part
= part
;
7594 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
7598 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
7599 i.e. line or page up or down. WIDGET is the Xaw scroll bar
7600 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
7601 the scroll bar. CALL_DATA is an integer specifying the action that
7602 has taken place. It's magnitude is in the range 0..height of the
7603 scroll bar. Negative values mean scroll towards buffer start.
7604 Values < height of scroll bar mean line-wise movement. */
7607 xaw_scroll_callback (widget
, client_data
, call_data
)
7609 XtPointer client_data
, call_data
;
7611 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7612 int position
= (int) call_data
;
7616 /* Get the height of the scroll bar. */
7618 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
7621 if (abs (position
) >= height
)
7622 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
7624 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
7625 it maps line-movement to call_data = max(5, height/20). */
7626 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
7627 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
7629 part
= scroll_bar_move_ratio
;
7631 window_being_scrolled
= bar
->window
;
7632 bar
->dragging
= Qnil
;
7633 last_scroll_bar_part
= part
;
7634 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
7638 #endif /* not USE_MOTIF */
7641 /* Create the widget for scroll bar BAR on frame F. Record the widget
7642 and X window of the scroll bar in BAR. */
7645 x_create_toolkit_scroll_bar (f
, bar
)
7647 struct scroll_bar
*bar
;
7653 char *scroll_bar_name
= "verticalScrollBar";
7654 unsigned long pixel
;
7659 /* LessTif 0.85, problems:
7661 1. When the mouse if over the scroll bar, the scroll bar will
7662 get keyboard events. I didn't find a way to turn this off.
7664 2. Do we have to explicitly set the cursor to get an arrow
7665 cursor (see below)? */
7667 /* Set resources. Create the widget. */
7668 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
7669 XtSetArg (av
[ac
], XmNminimum
, XM_SB_MIN
); ++ac
;
7670 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
7671 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
7672 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
7673 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
7674 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
7676 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
7679 XtSetArg (av
[ac
], XmNforeground
, pixel
);
7683 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
7686 XtSetArg (av
[ac
], XmNbackground
, pixel
);
7690 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
7691 scroll_bar_name
, av
, ac
);
7693 /* Add one callback for everything that can happen. */
7694 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
7696 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
7698 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
7700 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
7702 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
7704 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
7706 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
7709 /* Realize the widget. Only after that is the X window created. */
7710 XtRealizeWidget (widget
);
7712 /* Set the cursor to an arrow. I didn't find a resource to do that.
7713 And I'm wondering why it hasn't an arrow cursor by default. */
7714 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
7715 f
->output_data
.x
->nontext_cursor
);
7717 #else /* !USE_MOTIF i.e. use Xaw */
7719 /* Set resources. Create the widget. The background of the
7720 Xaw3d scroll bar widget is a little bit light for my taste.
7721 We don't alter it here to let users change it according
7722 to their taste with `emacs*verticalScrollBar.background: xxx'. */
7723 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
7724 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
7725 /* For smoother scrolling with Xaw3d -sm */
7726 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
7727 /* XtSetArg (av[ac], XtNbeNiceToColormap, True); ++ac; */
7729 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
7732 XtSetArg (av
[ac
], XtNforeground
, pixel
);
7736 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
7739 XtSetArg (av
[ac
], XtNbackground
, pixel
);
7743 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
7744 f
->output_data
.x
->edit_widget
, av
, ac
);
7748 char *val
= initial
;
7749 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
7750 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
7752 { /* ARROW_SCROLL */
7753 xaw3d_arrow_scroll
= True
;
7754 /* Isn't that just a personal preference ? -sm */
7755 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
7759 /* Define callbacks. */
7760 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
7761 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
7764 /* Realize the widget. Only after that is the X window created. */
7765 XtRealizeWidget (widget
);
7767 #endif /* !USE_MOTIF */
7769 /* Install an action hook that let's us detect when the user
7770 finishes interacting with a scroll bar. */
7771 if (action_hook_id
== 0)
7772 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
7774 /* Remember X window and widget in the scroll bar vector. */
7775 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
7776 xwindow
= XtWindow (widget
);
7777 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
7783 /* Set the thumb size and position of scroll bar BAR. We are currently
7784 displaying PORTION out of a whole WHOLE, and our position POSITION. */
7787 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
7788 struct scroll_bar
*bar
;
7789 int portion
, position
, whole
;
7792 Widget widget
= SCROLL_BAR_X_WIDGET (bar
);
7798 top
= (float) position
/ whole
;
7799 shown
= (float) portion
/ whole
;
7807 Boolean arrow1_selected
, arrow2_selected
;
7808 unsigned char flags
;
7809 XmScrollBarWidget sb
;
7811 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
7812 is the scroll bar's maximum and MIN is the scroll bar's minimum
7814 size
= shown
* XM_SB_RANGE
;
7815 size
= min (size
, XM_SB_RANGE
);
7816 size
= max (size
, 1);
7818 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
7819 value
= top
* XM_SB_RANGE
;
7820 value
= min (value
, XM_SB_MAX
- size
);
7821 value
= max (value
, XM_SB_MIN
);
7823 /* LessTif: Calling XmScrollBarSetValues after an increment or
7824 decrement turns off auto-repeat LessTif-internally. This can
7825 be seen in ScrollBar.c which resets Arrow1Selected and
7826 Arrow2Selected. It also sets internal flags so that LessTif
7827 believes the mouse is in the slider. We either have to change
7828 our code, or work around that by accessing private data. */
7830 sb
= (XmScrollBarWidget
) widget
;
7831 arrow1_selected
= sb
->scrollBar
.arrow1_selected
;
7832 arrow2_selected
= sb
->scrollBar
.arrow2_selected
;
7833 flags
= sb
->scrollBar
.flags
;
7835 if (NILP (bar
->dragging
))
7836 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
7837 else if (last_scroll_bar_part
== scroll_bar_down_arrow
)
7838 /* This has the negative side effect that the slider value is
7839 not what it would be if we scrolled here using line-wise or
7840 page-wise movement. */
7841 XmScrollBarSetValues (widget
, value
, XM_SB_RANGE
- value
, 0, 0, False
);
7844 /* If currently dragging, only update the slider size.
7845 This reduces flicker effects. */
7846 int old_value
, old_size
, increment
, page_increment
;
7848 XmScrollBarGetValues (widget
, &old_value
, &old_size
,
7849 &increment
, &page_increment
);
7850 XmScrollBarSetValues (widget
, old_value
,
7851 min (size
, XM_SB_RANGE
- old_value
),
7855 sb
->scrollBar
.arrow1_selected
= arrow1_selected
;
7856 sb
->scrollBar
.arrow2_selected
= arrow2_selected
;
7857 sb
->scrollBar
.flags
= flags
;
7859 #else /* !USE_MOTIF i.e. use Xaw */
7861 float old_top
, old_shown
;
7863 XtVaGetValues (widget
,
7864 XtNtopOfThumb
, &old_top
,
7865 XtNshown
, &old_shown
,
7869 /* Massage the top+shown values. */
7870 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
7871 top
= max (0, min (1, top
));
7874 /* Keep two pixels available for moving the thumb down. */
7875 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
7877 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
7878 check that your system's configuration file contains a define
7879 for `NARROWPROTO'. See s/freebsd.h for an example. */
7880 if (top
!= old_top
|| shown
!= old_shown
)
7882 if (NILP (bar
->dragging
))
7883 XawScrollbarSetThumb (widget
, top
, shown
);
7887 ScrollbarWidget sb
= (ScrollbarWidget
) widget
;
7890 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
7891 if (xaw3d_arrow_scroll
)
7893 /* Xaw3d stupidly ignores resize requests while dragging
7894 so we have to make it believe it's not in dragging mode. */
7895 scroll_mode
= sb
->scrollbar
.scroll_mode
;
7896 if (scroll_mode
== 2)
7897 sb
->scrollbar
.scroll_mode
= 0;
7900 /* Try to make the scrolling a tad smoother. */
7901 if (!xaw3d_pick_top
)
7902 shown
= min (shown
, old_shown
);
7904 XawScrollbarSetThumb (widget
, top
, shown
);
7907 if (xaw3d_arrow_scroll
&& scroll_mode
== 2)
7908 sb
->scrollbar
.scroll_mode
= scroll_mode
;
7913 #endif /* !USE_MOTIF */
7918 #endif /* USE_TOOLKIT_SCROLL_BARS */
7922 /************************************************************************
7923 Scroll bars, general
7924 ************************************************************************/
7926 /* Create a scroll bar and return the scroll bar vector for it. W is
7927 the Emacs window on which to create the scroll bar. TOP, LEFT,
7928 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
7931 static struct scroll_bar
*
7932 x_scroll_bar_create (w
, top
, left
, width
, height
)
7934 int top
, left
, width
, height
;
7936 struct frame
*f
= XFRAME (w
->frame
);
7937 struct scroll_bar
*bar
7938 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
7942 #if USE_TOOLKIT_SCROLL_BARS
7943 x_create_toolkit_scroll_bar (f
, bar
);
7944 #else /* not USE_TOOLKIT_SCROLL_BARS */
7946 XSetWindowAttributes a
;
7950 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
7951 if (a
.background_pixel
== -1)
7952 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
7954 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
7955 | ButtonMotionMask
| PointerMotionHintMask
7957 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
7959 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
7961 /* Clear the area of W that will serve as a scroll bar. This is
7962 for the case that a window has been split horizontally. In
7963 this case, no clear_frame is generated to reduce flickering. */
7964 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7966 window_box_height (w
), False
);
7968 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7969 /* Position and size of scroll bar. */
7970 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
7972 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
7974 /* Border width, depth, class, and visual. */
7981 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
7983 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7985 XSETWINDOW (bar
->window
, w
);
7986 XSETINT (bar
->top
, top
);
7987 XSETINT (bar
->left
, left
);
7988 XSETINT (bar
->width
, width
);
7989 XSETINT (bar
->height
, height
);
7990 XSETINT (bar
->start
, 0);
7991 XSETINT (bar
->end
, 0);
7992 bar
->dragging
= Qnil
;
7994 /* Add bar to its frame's list of scroll bars. */
7995 bar
->next
= FRAME_SCROLL_BARS (f
);
7997 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
7998 if (!NILP (bar
->next
))
7999 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8001 /* Map the window/widget. */
8002 #if USE_TOOLKIT_SCROLL_BARS
8003 XtMapWidget (SCROLL_BAR_X_WIDGET (bar
));
8004 XtConfigureWidget (SCROLL_BAR_X_WIDGET (bar
),
8005 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8007 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8009 #else /* not USE_TOOLKIT_SCROLL_BARS */
8010 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
8011 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8018 /* Draw BAR's handle in the proper position.
8020 If the handle is already drawn from START to END, don't bother
8021 redrawing it, unless REBUILD is non-zero; in that case, always
8022 redraw it. (REBUILD is handy for drawing the handle after expose
8025 Normally, we want to constrain the start and end of the handle to
8026 fit inside its rectangle, but if the user is dragging the scroll
8027 bar handle, we want to let them drag it down all the way, so that
8028 the bar's top is as far down as it goes; otherwise, there's no way
8029 to move to the very end of the buffer. */
8031 #ifndef USE_TOOLKIT_SCROLL_BARS
8034 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
8035 struct scroll_bar
*bar
;
8039 int dragging
= ! NILP (bar
->dragging
);
8040 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8041 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8042 GC gc
= f
->output_data
.x
->normal_gc
;
8044 /* If the display is already accurate, do nothing. */
8046 && start
== XINT (bar
->start
)
8047 && end
== XINT (bar
->end
))
8053 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
8054 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8055 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8057 /* Make sure the values are reasonable, and try to preserve
8058 the distance between start and end. */
8060 int length
= end
- start
;
8064 else if (start
> top_range
)
8066 end
= start
+ length
;
8070 else if (end
> top_range
&& ! dragging
)
8074 /* Store the adjusted setting in the scroll bar. */
8075 XSETINT (bar
->start
, start
);
8076 XSETINT (bar
->end
, end
);
8078 /* Clip the end position, just for display. */
8079 if (end
> top_range
)
8082 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
8083 below top positions, to make sure the handle is always at least
8084 that many pixels tall. */
8085 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8087 /* Draw the empty space above the handle. Note that we can't clear
8088 zero-height areas; that means "clear to end of window." */
8090 XClearArea (FRAME_X_DISPLAY (f
), w
,
8092 /* x, y, width, height, and exposures. */
8093 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8094 VERTICAL_SCROLL_BAR_TOP_BORDER
,
8095 inside_width
, start
,
8098 /* Change to proper foreground color if one is specified. */
8099 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8100 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8101 f
->output_data
.x
->scroll_bar_foreground_pixel
);
8103 /* Draw the handle itself. */
8104 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8106 /* x, y, width, height */
8107 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8108 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
8109 inside_width
, end
- start
);
8111 /* Restore the foreground color of the GC if we changed it above. */
8112 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8113 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8114 f
->output_data
.x
->foreground_pixel
);
8116 /* Draw the empty space below the handle. Note that we can't
8117 clear zero-height areas; that means "clear to end of window." */
8118 if (end
< inside_height
)
8119 XClearArea (FRAME_X_DISPLAY (f
), w
,
8121 /* x, y, width, height, and exposures. */
8122 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8123 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
8124 inside_width
, inside_height
- end
,
8132 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8134 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
8138 x_scroll_bar_remove (bar
)
8139 struct scroll_bar
*bar
;
8143 #if USE_TOOLKIT_SCROLL_BARS
8144 XtDestroyWidget (SCROLL_BAR_X_WIDGET (bar
));
8145 #else /* not USE_TOOLKIT_SCROLL_BARS */
8147 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8148 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
8150 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8152 /* Disassociate this scroll bar from its window. */
8153 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
8159 /* Set the handle of the vertical scroll bar for WINDOW to indicate
8160 that we are displaying PORTION characters out of a total of WHOLE
8161 characters, starting at POSITION. If WINDOW has no scroll bar,
8165 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
8167 int portion
, whole
, position
;
8169 struct frame
*f
= XFRAME (w
->frame
);
8170 struct scroll_bar
*bar
;
8171 int top
, height
, left
, sb_left
, width
, sb_width
;
8172 int window_x
, window_y
, window_width
, window_height
;
8174 /* Get window dimensions. */
8175 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
8177 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
8178 height
= window_height
;
8180 /* Compute the left edge of the scroll bar area. */
8181 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8182 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
8184 left
= XFASTINT (w
->left
);
8185 left
*= CANON_X_UNIT (f
);
8186 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
8188 /* Compute the width of the scroll bar which might be less than
8189 the width of the area reserved for the scroll bar. */
8190 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
8191 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
8195 /* Compute the left edge of the scroll bar. */
8196 #ifdef USE_TOOLKIT_SCROLL_BARS
8197 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8198 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
8200 sb_left
= left
+ (width
- sb_width
) / 2;
8202 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8203 sb_left
= left
+ width
- sb_width
;
8208 /* Does the scroll bar exist yet? */
8209 if (NILP (w
->vertical_scroll_bar
))
8212 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8213 left
, top
, width
, height
, False
);
8215 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
8219 /* It may just need to be moved and resized. */
8220 unsigned int mask
= 0;
8222 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
8226 if (sb_left
!= XINT (bar
->left
))
8228 if (top
!= XINT (bar
->top
))
8230 if (sb_width
!= XINT (bar
->width
))
8232 if (height
!= XINT (bar
->height
))
8235 #ifdef USE_TOOLKIT_SCROLL_BARS
8237 /* Since toolkit scroll bars are smaller than the space reserved
8238 for them on the frame, we have to clear "under" them. */
8239 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8240 left
, top
, width
, height
, False
);
8242 /* Move/size the scroll bar widget. */
8244 XtConfigureWidget (SCROLL_BAR_X_WIDGET (bar
),
8245 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8247 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8250 #else /* not USE_TOOLKIT_SCROLL_BARS */
8252 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
8254 /* Clear areas not covered by the scroll bar. This makes sure a
8255 previous mode line display is cleared after C-x 2 C-x 1, for
8256 example. Non-toolkit scroll bars are as wide as the area
8257 reserved for scroll bars - trim at both sides. */
8258 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8259 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8261 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8262 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8263 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8267 /* Move/size the scroll bar window. */
8272 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
8274 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
8276 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
8280 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8282 /* Remember new settings. */
8283 XSETINT (bar
->left
, sb_left
);
8284 XSETINT (bar
->top
, top
);
8285 XSETINT (bar
->width
, sb_width
);
8286 XSETINT (bar
->height
, height
);
8291 #if USE_TOOLKIT_SCROLL_BARS
8292 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
8293 #else /* not USE_TOOLKIT_SCROLL_BARS */
8294 /* Set the scroll bar's current state, unless we're currently being
8296 if (NILP (bar
->dragging
))
8298 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
8301 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
8304 int start
= ((double) position
* top_range
) / whole
;
8305 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
8306 x_scroll_bar_set_handle (bar
, start
, end
, 0);
8309 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8311 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
8315 /* The following three hooks are used when we're doing a thorough
8316 redisplay of the frame. We don't explicitly know which scroll bars
8317 are going to be deleted, because keeping track of when windows go
8318 away is a real pain - "Can you say set-window-configuration, boys
8319 and girls?" Instead, we just assert at the beginning of redisplay
8320 that *all* scroll bars are to be removed, and then save a scroll bar
8321 from the fiery pit when we actually redisplay its window. */
8323 /* Arrange for all scroll bars on FRAME to be removed at the next call
8324 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
8325 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
8328 XTcondemn_scroll_bars (frame
)
8331 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
8332 while (! NILP (FRAME_SCROLL_BARS (frame
)))
8335 bar
= FRAME_SCROLL_BARS (frame
);
8336 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
8337 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
8338 XSCROLL_BAR (bar
)->prev
= Qnil
;
8339 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
8340 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
8341 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
8345 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
8346 Note that WINDOW isn't necessarily condemned at all. */
8348 XTredeem_scroll_bar (window
)
8349 struct window
*window
;
8351 struct scroll_bar
*bar
;
8353 /* We can't redeem this window's scroll bar if it doesn't have one. */
8354 if (NILP (window
->vertical_scroll_bar
))
8357 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
8359 /* Unlink it from the condemned list. */
8361 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
8363 if (NILP (bar
->prev
))
8365 /* If the prev pointer is nil, it must be the first in one of
8367 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
8368 /* It's not condemned. Everything's fine. */
8370 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
8371 window
->vertical_scroll_bar
))
8372 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
8374 /* If its prev pointer is nil, it must be at the front of
8375 one or the other! */
8379 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
8381 if (! NILP (bar
->next
))
8382 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
8384 bar
->next
= FRAME_SCROLL_BARS (f
);
8386 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8387 if (! NILP (bar
->next
))
8388 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8392 /* Remove all scroll bars on FRAME that haven't been saved since the
8393 last call to `*condemn_scroll_bars_hook'. */
8396 XTjudge_scroll_bars (f
)
8399 Lisp_Object bar
, next
;
8401 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
8403 /* Clear out the condemned list now so we won't try to process any
8404 more events on the hapless scroll bars. */
8405 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
8407 for (; ! NILP (bar
); bar
= next
)
8409 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
8411 x_scroll_bar_remove (b
);
8414 b
->next
= b
->prev
= Qnil
;
8417 /* Now there should be no references to the condemned scroll bars,
8418 and they should get garbage-collected. */
8422 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
8423 is a no-op when using toolkit scroll bars.
8425 This may be called from a signal handler, so we have to ignore GC
8429 x_scroll_bar_expose (bar
, event
)
8430 struct scroll_bar
*bar
;
8433 #ifndef USE_TOOLKIT_SCROLL_BARS
8435 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8436 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8437 GC gc
= f
->output_data
.x
->normal_gc
;
8438 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
8442 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
8444 /* Draw a one-pixel border just inside the edges of the scroll bar. */
8445 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8447 /* x, y, width, height */
8449 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
8450 XINT (bar
->height
) - 1);
8454 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8457 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
8458 is set to something other than no_event, it is enqueued.
8460 This may be called from a signal handler, so we have to ignore GC
8463 #ifndef USE_TOOLKIT_SCROLL_BARS
8466 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
8467 struct scroll_bar
*bar
;
8469 struct input_event
*emacs_event
;
8471 if (! GC_WINDOWP (bar
->window
))
8474 emacs_event
->kind
= scroll_bar_click
;
8475 emacs_event
->code
= event
->xbutton
.button
- Button1
;
8476 emacs_event
->modifiers
8477 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
8478 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
8479 event
->xbutton
.state
)
8480 | (event
->type
== ButtonRelease
8483 emacs_event
->frame_or_window
= bar
->window
;
8484 emacs_event
->timestamp
= event
->xbutton
.time
;
8487 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8489 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8492 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8493 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
8496 if (y
> top_range
) y
= top_range
;
8498 if (y
< XINT (bar
->start
))
8499 emacs_event
->part
= scroll_bar_above_handle
;
8500 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
8501 emacs_event
->part
= scroll_bar_handle
;
8503 emacs_event
->part
= scroll_bar_below_handle
;
8505 /* Just because the user has clicked on the handle doesn't mean
8506 they want to drag it. Lisp code needs to be able to decide
8507 whether or not we're dragging. */
8509 /* If the user has just clicked on the handle, record where they're
8511 if (event
->type
== ButtonPress
8512 && emacs_event
->part
== scroll_bar_handle
)
8513 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
8516 /* If the user has released the handle, set it to its final position. */
8517 if (event
->type
== ButtonRelease
8518 && ! NILP (bar
->dragging
))
8520 int new_start
= y
- XINT (bar
->dragging
);
8521 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8523 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8524 bar
->dragging
= Qnil
;
8527 /* Same deal here as the other #if 0. */
8529 /* Clicks on the handle are always reported as occurring at the top of
8531 if (emacs_event
->part
== scroll_bar_handle
)
8532 emacs_event
->x
= bar
->start
;
8534 XSETINT (emacs_event
->x
, y
);
8536 XSETINT (emacs_event
->x
, y
);
8539 XSETINT (emacs_event
->y
, top_range
);
8543 /* Handle some mouse motion while someone is dragging the scroll bar.
8545 This may be called from a signal handler, so we have to ignore GC
8549 x_scroll_bar_note_movement (bar
, event
)
8550 struct scroll_bar
*bar
;
8553 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
8555 last_mouse_movement_time
= event
->xmotion
.time
;
8558 XSETVECTOR (last_mouse_scroll_bar
, bar
);
8560 /* If we're dragging the bar, display it. */
8561 if (! GC_NILP (bar
->dragging
))
8563 /* Where should the handle be now? */
8564 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
8566 if (new_start
!= XINT (bar
->start
))
8568 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8570 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8575 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8577 /* Return information to the user about the current position of the mouse
8578 on the scroll bar. */
8581 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
8583 Lisp_Object
*bar_window
;
8584 enum scroll_bar_part
*part
;
8586 unsigned long *time
;
8588 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
8589 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8590 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8592 Window dummy_window
;
8594 unsigned int dummy_mask
;
8598 /* Get the mouse's position relative to the scroll bar window, and
8600 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
8602 /* Root, child, root x and root y. */
8603 &dummy_window
, &dummy_window
,
8604 &dummy_coord
, &dummy_coord
,
8606 /* Position relative to scroll bar. */
8609 /* Mouse buttons and modifier keys. */
8616 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8619 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8621 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
8623 if (! NILP (bar
->dragging
))
8624 win_y
-= XINT (bar
->dragging
);
8628 if (win_y
> top_range
)
8632 *bar_window
= bar
->window
;
8634 if (! NILP (bar
->dragging
))
8635 *part
= scroll_bar_handle
;
8636 else if (win_y
< XINT (bar
->start
))
8637 *part
= scroll_bar_above_handle
;
8638 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
8639 *part
= scroll_bar_handle
;
8641 *part
= scroll_bar_below_handle
;
8643 XSETINT (*x
, win_y
);
8644 XSETINT (*y
, top_range
);
8647 last_mouse_scroll_bar
= Qnil
;
8650 *time
= last_mouse_movement_time
;
8656 /* The screen has been cleared so we may have changed foreground or
8657 background colors, and the scroll bars may need to be redrawn.
8658 Clear out the scroll bars, and ask for expose events, so we can
8662 x_scroll_bar_clear (f
)
8665 #ifndef USE_TOOLKIT_SCROLL_BARS
8668 /* We can have scroll bars even if this is 0,
8669 if we just turned off scroll bar mode.
8670 But in that case we should not clear them. */
8671 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8672 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
8673 bar
= XSCROLL_BAR (bar
)->next
)
8674 XClearArea (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
8676 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8679 /* This processes Expose events from the menu-bar specific X event
8680 loop in xmenu.c. This allows to redisplay the frame if necessary
8681 when handling menu-bar or pop-up items. */
8684 process_expose_from_menu (event
)
8688 struct x_display_info
*dpyinfo
;
8689 int frame_exposed_p
= 0;
8693 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
8694 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
8697 if (f
->async_visible
== 0)
8699 f
->async_visible
= 1;
8700 f
->async_iconified
= 0;
8701 f
->output_data
.x
->has_been_visible
= 1;
8702 SET_FRAME_GARBAGED (f
);
8706 expose_frame (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
8707 event
.xexpose
.x
, event
.xexpose
.y
,
8708 event
.xexpose
.width
, event
.xexpose
.height
);
8709 frame_exposed_p
= 1;
8714 struct scroll_bar
*bar
8715 = x_window_to_scroll_bar (event
.xexpose
.window
);
8718 x_scroll_bar_expose (bar
, &event
);
8722 return frame_exposed_p
;
8725 /* Define a queue to save up SelectionRequest events for later handling. */
8727 struct selection_event_queue
8730 struct selection_event_queue
*next
;
8733 static struct selection_event_queue
*queue
;
8735 /* Nonzero means queue up certain events--don't process them yet. */
8737 static int x_queue_selection_requests
;
8739 /* Queue up an X event *EVENT, to be processed later. */
8742 x_queue_event (f
, event
)
8746 struct selection_event_queue
*queue_tmp
8747 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
8749 if (queue_tmp
!= NULL
)
8751 queue_tmp
->event
= *event
;
8752 queue_tmp
->next
= queue
;
8757 /* Take all the queued events and put them back
8758 so that they get processed afresh. */
8761 x_unqueue_events (display
)
8764 while (queue
!= NULL
)
8766 struct selection_event_queue
*queue_tmp
= queue
;
8767 XPutBackEvent (display
, &queue_tmp
->event
);
8768 queue
= queue_tmp
->next
;
8769 xfree ((char *)queue_tmp
);
8773 /* Start queuing SelectionRequest events. */
8776 x_start_queuing_selection_requests (display
)
8779 x_queue_selection_requests
++;
8782 /* Stop queuing SelectionRequest events. */
8785 x_stop_queuing_selection_requests (display
)
8788 x_queue_selection_requests
--;
8789 x_unqueue_events (display
);
8792 /* The main X event-reading loop - XTread_socket. */
8794 /* Time stamp of enter window event. This is only used by XTread_socket,
8795 but we have to put it out here, since static variables within functions
8796 sometimes don't work. */
8798 static Time enter_timestamp
;
8800 /* This holds the state XLookupString needs to implement dead keys
8801 and other tricks known as "compose processing". _X Window System_
8802 says that a portable program can't use this, but Stephen Gildea assures
8803 me that letting the compiler initialize it to zeros will work okay.
8805 This must be defined outside of XTread_socket, for the same reasons
8806 given for enter_time stamp, above. */
8808 static XComposeStatus compose_status
;
8810 /* Record the last 100 characters stored
8811 to help debug the loss-of-chars-during-GC problem. */
8813 static int temp_index
;
8814 static short temp_buffer
[100];
8816 /* Set this to nonzero to fake an "X I/O error"
8817 on a particular display. */
8819 struct x_display_info
*XTread_socket_fake_io_error
;
8821 /* When we find no input here, we occasionally do a no-op command
8822 to verify that the X server is still running and we can still talk with it.
8823 We try all the open displays, one by one.
8824 This variable is used for cycling thru the displays. */
8826 static struct x_display_info
*next_noop_dpyinfo
;
8828 #define SET_SAVED_MENU_EVENT(size) \
8831 if (f->output_data.x->saved_menu_event == 0) \
8832 f->output_data.x->saved_menu_event \
8833 = (XEvent *) xmalloc (sizeof (XEvent)); \
8834 bcopy (&event, f->output_data.x->saved_menu_event, size); \
8835 if (numchars >= 1) \
8837 bufp->kind = menu_bar_activate_event; \
8838 XSETFRAME (bufp->frame_or_window, f); \
8846 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
8847 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
8849 /* Read events coming from the X server.
8850 This routine is called by the SIGIO handler.
8851 We return as soon as there are no more events to be read.
8853 Events representing keys are stored in buffer BUFP,
8854 which can hold up to NUMCHARS characters.
8855 We return the number of characters stored into the buffer,
8856 thus pretending to be `read'.
8858 EXPECTED is nonzero if the caller knows input is available. */
8861 XTread_socket (sd
, bufp
, numchars
, expected
)
8863 /* register */ struct input_event
*bufp
;
8864 /* register */ int numchars
;
8871 int event_found
= 0;
8872 struct x_display_info
*dpyinfo
;
8874 if (interrupt_input_blocked
)
8876 interrupt_input_pending
= 1;
8880 interrupt_input_pending
= 0;
8883 /* So people can tell when we have read the available input. */
8884 input_signal_count
++;
8887 abort (); /* Don't think this happens. */
8889 /* Find the display we are supposed to read input for.
8890 It's the one communicating on descriptor SD. */
8891 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
8893 #if 0 /* This ought to be unnecessary; let's verify it. */
8895 /* If available, Xlib uses FIOSNBIO to make the socket
8896 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
8897 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
8898 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
8899 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
8900 #endif /* ! defined (FIOSNBIO) */
8903 #if 0 /* This code can't be made to work, with multiple displays,
8904 and appears not to be used on any system any more.
8905 Also keyboard.c doesn't turn O_NDELAY on and off
8906 for X connections. */
8909 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
8911 extern int read_alarm_should_throw
;
8912 read_alarm_should_throw
= 1;
8913 XPeekEvent (dpyinfo
->display
, &event
);
8914 read_alarm_should_throw
= 0;
8916 #endif /* HAVE_SELECT */
8920 /* For debugging, this gives a way to fake an I/O error. */
8921 if (dpyinfo
== XTread_socket_fake_io_error
)
8923 XTread_socket_fake_io_error
= 0;
8924 x_io_error_quitter (dpyinfo
->display
);
8927 while (XPending (dpyinfo
->display
))
8929 XNextEvent (dpyinfo
->display
, &event
);
8933 /* Filter events for the current X input method.
8934 XFilterEvent returns non-zero if the input method has
8935 consumed the event. We pass the frame's X window to
8936 XFilterEvent because that's the one for which the IC
8938 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
8939 event
.xclient
.window
);
8940 if (XFilterEvent (&event
, f1
? FRAME_X_WINDOW (f1
) : None
))
8950 if (event
.xclient
.message_type
8951 == dpyinfo
->Xatom_wm_protocols
8952 && event
.xclient
.format
== 32)
8954 if (event
.xclient
.data
.l
[0]
8955 == dpyinfo
->Xatom_wm_take_focus
)
8957 /* Use x_any_window_to_frame because this
8958 could be the shell widget window
8959 if the frame has no title bar. */
8960 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
8962 /* Not quite sure this is needed -pd */
8963 if (f
&& FRAME_XIC (f
))
8964 XSetICFocus (FRAME_XIC (f
));
8966 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
8967 instructs the WM to set the input focus automatically for
8968 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
8969 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
8970 it has set the focus. So, XSetInputFocus below is not
8973 The call to XSetInputFocus below has also caused trouble. In
8974 cases where the XSetInputFocus done by the WM and the one
8975 below are temporally close (on a fast machine), the call
8976 below can generate additional FocusIn events which confuse
8979 /* Since we set WM_TAKE_FOCUS, we must call
8980 XSetInputFocus explicitly. But not if f is null,
8981 since that might be an event for a deleted frame. */
8984 Display
*d
= event
.xclient
.display
;
8985 /* Catch and ignore errors, in case window has been
8986 iconified by a window manager such as GWM. */
8987 int count
= x_catch_errors (d
);
8988 XSetInputFocus (d
, event
.xclient
.window
,
8989 /* The ICCCM says this is
8990 the only valid choice. */
8992 event
.xclient
.data
.l
[1]);
8993 /* This is needed to detect the error
8994 if there is an error. */
8996 x_uncatch_errors (d
, count
);
8998 /* Not certain about handling scroll bars here */
9001 else if (event
.xclient
.data
.l
[0]
9002 == dpyinfo
->Xatom_wm_save_yourself
)
9004 /* Save state modify the WM_COMMAND property to
9005 something which can reinstate us. This notifies
9006 the session manager, who's looking for such a
9007 PropertyNotify. Can restart processing when
9008 a keyboard or mouse event arrives. */
9011 f
= x_top_window_to_frame (dpyinfo
,
9012 event
.xclient
.window
);
9014 /* This is just so we only give real data once
9015 for a single Emacs process. */
9016 if (f
== SELECTED_FRAME ())
9017 XSetCommand (FRAME_X_DISPLAY (f
),
9018 event
.xclient
.window
,
9019 initial_argv
, initial_argc
);
9021 XSetCommand (FRAME_X_DISPLAY (f
),
9022 event
.xclient
.window
,
9026 else if (event
.xclient
.data
.l
[0]
9027 == dpyinfo
->Xatom_wm_delete_window
)
9030 = x_any_window_to_frame (dpyinfo
,
9031 event
.xclient
.window
);
9038 bufp
->kind
= delete_window_event
;
9039 XSETFRAME (bufp
->frame_or_window
, f
);
9047 else if (event
.xclient
.message_type
9048 == dpyinfo
->Xatom_wm_configure_denied
)
9051 else if (event
.xclient
.message_type
9052 == dpyinfo
->Xatom_wm_window_moved
)
9056 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9058 new_x
= event
.xclient
.data
.s
[0];
9059 new_y
= event
.xclient
.data
.s
[1];
9063 f
->output_data
.x
->left_pos
= new_x
;
9064 f
->output_data
.x
->top_pos
= new_y
;
9068 else if (event
.xclient
.message_type
9069 == dpyinfo
->Xatom_editres
)
9072 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
9073 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
9076 #endif /* HACK_EDITRES */
9077 else if ((event
.xclient
.message_type
9078 == dpyinfo
->Xatom_DONE
)
9079 || (event
.xclient
.message_type
9080 == dpyinfo
->Xatom_PAGE
))
9082 /* Ghostview job completed. Kill it. We could
9083 reply with "Next" if we received "Page", but we
9084 currently never do because we are interested in
9085 images, only, which should have 1 page. */
9086 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
9088 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9089 x_kill_gs_process (pixmap
, f
);
9090 expose_frame (f
, 0, 0, 0, 0);
9092 #ifdef USE_TOOLKIT_SCROLL_BARS
9093 /* Scroll bar callbacks send a ClientMessage from which
9094 we construct an input_event. */
9095 else if (event
.xclient
.message_type
9096 == dpyinfo
->Xatom_Scrollbar
)
9098 x_scroll_bar_to_input_event (&event
, bufp
);
9099 ++bufp
, ++count
, --numchars
;
9102 #endif /* USE_TOOLKIT_SCROLL_BARS */
9108 case SelectionNotify
:
9109 #ifdef USE_X_TOOLKIT
9110 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
9112 #endif /* not USE_X_TOOLKIT */
9113 x_handle_selection_notify (&event
.xselection
);
9116 case SelectionClear
: /* Someone has grabbed ownership. */
9117 #ifdef USE_X_TOOLKIT
9118 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
9120 #endif /* USE_X_TOOLKIT */
9122 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
9127 bufp
->kind
= selection_clear_event
;
9128 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
9129 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
9130 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
9131 bufp
->frame_or_window
= Qnil
;
9139 case SelectionRequest
: /* Someone wants our selection. */
9140 #ifdef USE_X_TOOLKIT
9141 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
9143 #endif /* USE_X_TOOLKIT */
9144 if (x_queue_selection_requests
)
9145 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
9149 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
9154 bufp
->kind
= selection_request_event
;
9155 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
9156 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
9157 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
9158 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
9159 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
9160 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
9161 bufp
->frame_or_window
= Qnil
;
9169 case PropertyNotify
:
9170 #ifdef USE_X_TOOLKIT
9171 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
9173 #endif /* not USE_X_TOOLKIT */
9174 x_handle_property_notify (&event
.xproperty
);
9177 case ReparentNotify
:
9178 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
9182 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
9183 x_real_positions (f
, &x
, &y
);
9184 f
->output_data
.x
->left_pos
= x
;
9185 f
->output_data
.x
->top_pos
= y
;
9190 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
9193 if (f
->async_visible
== 0)
9195 f
->async_visible
= 1;
9196 f
->async_iconified
= 0;
9197 f
->output_data
.x
->has_been_visible
= 1;
9198 SET_FRAME_GARBAGED (f
);
9201 expose_frame (x_window_to_frame (dpyinfo
,
9202 event
.xexpose
.window
),
9203 event
.xexpose
.x
, event
.xexpose
.y
,
9204 event
.xexpose
.width
, event
.xexpose
.height
);
9208 #ifdef USE_TOOLKIT_SCROLL_BARS
9209 /* Dispatch event to the widget. */
9211 #else /* not USE_TOOLKIT_SCROLL_BARS */
9212 struct scroll_bar
*bar
9213 = x_window_to_scroll_bar (event
.xexpose
.window
);
9216 x_scroll_bar_expose (bar
, &event
);
9217 #ifdef USE_X_TOOLKIT
9220 #endif /* USE_X_TOOLKIT */
9221 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9225 case GraphicsExpose
: /* This occurs when an XCopyArea's
9226 source area was obscured or not
9228 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
9232 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
9233 event
.xgraphicsexpose
.width
,
9234 event
.xgraphicsexpose
.height
);
9236 #ifdef USE_X_TOOLKIT
9239 #endif /* USE_X_TOOLKIT */
9242 case NoExpose
: /* This occurs when an XCopyArea's
9243 source area was completely
9248 /* Redo the mouse-highlight after the tooltip has gone. */
9249 if (event
.xmap
.window
== tip_window
)
9252 redo_mouse_highlight ();
9255 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
9256 if (f
) /* F may no longer exist if
9257 the frame was deleted. */
9259 /* While a frame is unmapped, display generation is
9260 disabled; you don't want to spend time updating a
9261 display that won't ever be seen. */
9262 f
->async_visible
= 0;
9263 /* We can't distinguish, from the event, whether the window
9264 has become iconified or invisible. So assume, if it
9265 was previously visible, than now it is iconified.
9266 But x_make_frame_invisible clears both
9267 the visible flag and the iconified flag;
9268 and that way, we know the window is not iconified now. */
9269 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
9271 f
->async_iconified
= 1;
9273 bufp
->kind
= iconify_event
;
9274 XSETFRAME (bufp
->frame_or_window
, f
);
9283 if (event
.xmap
.window
== tip_window
)
9284 /* The tooltip has been drawn already. Avoid
9285 the SET_FRAME_GARBAGED below. */
9288 /* We use x_top_window_to_frame because map events can
9289 come for sub-windows and they don't mean that the
9290 frame is visible. */
9291 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
9294 f
->async_visible
= 1;
9295 f
->async_iconified
= 0;
9296 f
->output_data
.x
->has_been_visible
= 1;
9298 /* wait_reading_process_input will notice this and update
9299 the frame's display structures. */
9300 SET_FRAME_GARBAGED (f
);
9304 bufp
->kind
= deiconify_event
;
9305 XSETFRAME (bufp
->frame_or_window
, f
);
9310 else if (! NILP (Vframe_list
)
9311 && ! NILP (XCDR (Vframe_list
)))
9312 /* Force a redisplay sooner or later
9313 to update the frame titles
9314 in case this is the second frame. */
9315 record_asynch_buffer_change ();
9320 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
9323 /* I couldn't find a way to prevent LessTif scroll bars
9324 from consuming key events. */
9327 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
9329 if (widget
&& XmIsScrollBar (widget
))
9331 widget
= XtParent (widget
);
9332 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
9335 #endif /* USE_MOTIF */
9339 KeySym keysym
, orig_keysym
;
9340 /* al%imercury@uunet.uu.net says that making this 81 instead of
9341 80 fixed a bug whereby meta chars made his Emacs hang. */
9342 unsigned char copy_buffer
[81];
9346 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
9347 extra_keyboard_modifiers
);
9348 modifiers
= event
.xkey
.state
;
9350 /* This will have to go some day... */
9352 /* make_lispy_event turns chars into control chars.
9353 Don't do it here because XLookupString is too eager. */
9354 event
.xkey
.state
&= ~ControlMask
;
9355 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
9356 | dpyinfo
->super_mod_mask
9357 | dpyinfo
->hyper_mod_mask
9358 | dpyinfo
->alt_mod_mask
);
9360 /* In case Meta is ComposeCharacter,
9361 clear its status. According to Markus Ehrnsperger
9362 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
9363 this enables ComposeCharacter to work whether or
9364 not it is combined with Meta. */
9365 if (modifiers
& dpyinfo
->meta_mod_mask
)
9366 bzero (&compose_status
, sizeof (compose_status
));
9371 unsigned char *copy_bufptr
= copy_buffer
;
9372 int copy_bufsiz
= sizeof (copy_buffer
);
9373 Status status_return
;
9375 nbytes
= XmbLookupString (FRAME_XIC (f
),
9376 &event
.xkey
, copy_bufptr
,
9377 copy_bufsiz
, &keysym
,
9379 if (status_return
== XBufferOverflow
)
9381 copy_bufsiz
= nbytes
+ 1;
9382 copy_bufptr
= (char *) alloca (copy_bufsiz
);
9383 nbytes
= XmbLookupString (FRAME_XIC (f
),
9384 &event
.xkey
, copy_bufptr
,
9385 copy_bufsiz
, &keysym
,
9389 if (status_return
== XLookupNone
)
9391 else if (status_return
== XLookupChars
)
9393 else if (status_return
!= XLookupKeySym
9394 && status_return
!= XLookupBoth
)
9398 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
9399 80, &keysym
, &compose_status
);
9401 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
9402 80, &keysym
, &compose_status
);
9405 orig_keysym
= keysym
;
9409 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
9410 || keysym
== XK_Delete
9411 #ifdef XK_ISO_Left_Tab
9412 || (keysym
>= XK_ISO_Left_Tab
&& keysym
<= XK_ISO_Enter
)
9414 || (keysym
>= XK_Kanji
&& keysym
<= XK_Eisu_toggle
)
9415 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
9416 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
9418 /* This recognizes the "extended function keys".
9419 It seems there's no cleaner way.
9420 Test IsModifierKey to avoid handling mode_switch
9422 || ((unsigned) (keysym
) >= XK_Select
9423 && (unsigned)(keysym
) < XK_KP_Space
)
9425 #ifdef XK_dead_circumflex
9426 || orig_keysym
== XK_dead_circumflex
9428 #ifdef XK_dead_grave
9429 || orig_keysym
== XK_dead_grave
9431 #ifdef XK_dead_tilde
9432 || orig_keysym
== XK_dead_tilde
9434 #ifdef XK_dead_diaeresis
9435 || orig_keysym
== XK_dead_diaeresis
9437 #ifdef XK_dead_macron
9438 || orig_keysym
== XK_dead_macron
9440 #ifdef XK_dead_degree
9441 || orig_keysym
== XK_dead_degree
9443 #ifdef XK_dead_acute
9444 || orig_keysym
== XK_dead_acute
9446 #ifdef XK_dead_cedilla
9447 || orig_keysym
== XK_dead_cedilla
9449 #ifdef XK_dead_breve
9450 || orig_keysym
== XK_dead_breve
9452 #ifdef XK_dead_ogonek
9453 || orig_keysym
== XK_dead_ogonek
9455 #ifdef XK_dead_caron
9456 || orig_keysym
== XK_dead_caron
9458 #ifdef XK_dead_doubleacute
9459 || orig_keysym
== XK_dead_doubleacute
9461 #ifdef XK_dead_abovedot
9462 || orig_keysym
== XK_dead_abovedot
9464 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
9465 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
9466 /* Any "vendor-specific" key is ok. */
9467 || (orig_keysym
& (1 << 28)))
9468 && ! (IsModifierKey (orig_keysym
)
9470 #ifdef XK_Mode_switch
9471 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
9474 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
9476 #endif /* not HAVE_X11R5 */
9479 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
9481 temp_buffer
[temp_index
++] = keysym
;
9482 bufp
->kind
= non_ascii_keystroke
;
9483 bufp
->code
= keysym
;
9484 XSETFRAME (bufp
->frame_or_window
, f
);
9486 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
9488 bufp
->timestamp
= event
.xkey
.time
;
9493 else if (numchars
> nbytes
)
9497 for (i
= 0; i
< nbytes
; i
++)
9499 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
9501 temp_buffer
[temp_index
++] = copy_buffer
[i
];
9502 bufp
->kind
= ascii_keystroke
;
9503 bufp
->code
= copy_buffer
[i
];
9504 XSETFRAME (bufp
->frame_or_window
, f
);
9506 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
9508 bufp
->timestamp
= event
.xkey
.time
;
9515 if (keysym
== NoSymbol
)
9525 /* Don't dispatch this event since XtDispatchEvent calls
9526 XFilterEvent, and two calls in a row may freeze the
9535 /* Don't dispatch this event since XtDispatchEvent calls
9536 XFilterEvent, and two calls in a row may freeze the
9543 /* Here's a possible interpretation of the whole
9544 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If
9545 you get a FocusIn event, you have to get a FocusOut
9546 event before you relinquish the focus. If you
9547 haven't received a FocusIn event, then a mere
9548 LeaveNotify is enough to free you. */
9552 int from_menu_bar_p
= 0;
9554 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
9556 #ifdef LESSTIF_VERSION
9557 /* When clicking outside of a menu bar popup to close
9558 it, we get a FocusIn/ EnterNotify sequence of
9559 events. The flag event.xcrossing.focus is not set
9560 in the EnterNotify event of that sequence because
9561 the focus is in the menu bar,
9562 event.xcrossing.window is the frame's X window.
9563 Unconditionally setting the focus frame to null in
9564 this case is not the right thing, because no event
9565 follows that could set the focus frame to the right
9568 This could be a LessTif bug, but I wasn't able to
9569 reproduce the behavior in a simple test program.
9571 (gerd, LessTif 0.88.1). */
9573 if (!event
.xcrossing
.focus
9575 && f
->output_data
.x
->menubar_widget
)
9580 XGetInputFocus (FRAME_X_DISPLAY (f
), &focus
, &revert
);
9581 if (focus
== XtWindow (f
->output_data
.x
->menubar_widget
))
9582 from_menu_bar_p
= 1;
9584 #endif /* LESSTIF_VERSION */
9586 if (event
.xcrossing
.focus
|| from_menu_bar_p
)
9588 /* Avoid nasty pop/raise loops. */
9589 if (f
&& (!(f
->auto_raise
)
9591 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
9593 x_new_focus_frame (dpyinfo
, f
);
9594 enter_timestamp
= event
.xcrossing
.time
;
9597 else if (f
== dpyinfo
->x_focus_frame
)
9598 x_new_focus_frame (dpyinfo
, 0);
9600 /* EnterNotify counts as mouse movement,
9601 so update things that depend on mouse position. */
9602 if (f
&& !f
->output_data
.x
->busy_p
)
9603 note_mouse_movement (f
, &event
.xmotion
);
9608 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
9609 if (event
.xfocus
.detail
!= NotifyPointer
)
9610 dpyinfo
->x_focus_event_frame
= f
;
9613 x_new_focus_frame (dpyinfo
, f
);
9615 /* Don't stop displaying the initial startup message
9616 for a switch-frame event we don't need. */
9617 if (GC_NILP (Vterminal_frame
)
9618 && GC_CONSP (Vframe_list
)
9619 && !GC_NILP (XCDR (Vframe_list
)))
9621 bufp
->kind
= FOCUS_IN_EVENT
;
9622 XSETFRAME (bufp
->frame_or_window
, f
);
9623 ++bufp
, ++count
, --numchars
;
9628 if (f
&& FRAME_XIC (f
))
9629 XSetICFocus (FRAME_XIC (f
));
9635 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
9639 int from_menu_bar_p
= 0;
9641 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9643 /* If we move outside the frame, then we're
9644 certainly no longer on any text in the frame. */
9645 clear_mouse_face (dpyinfo
);
9646 dpyinfo
->mouse_face_mouse_frame
= 0;
9649 /* Generate a nil HELP_EVENT to cancel a help-echo.
9650 Do it only if there's something to cancel.
9651 Otherwise, the startup message is cleared when
9652 the mouse leaves the frame. */
9653 if (any_help_event_p
)
9655 XSETFRAME (frame
, f
);
9656 bufp
->kind
= HELP_EVENT
;
9657 bufp
->frame_or_window
= Fcons (frame
, Qnil
);
9658 ++bufp
, ++count
, --numchars
;
9661 #ifdef LESSTIF_VERSION
9662 /* Please see the comment at the start of the
9663 EnterNotify case. */
9664 if (!event
.xcrossing
.focus
9665 && f
->output_data
.x
->menubar_widget
)
9669 XGetInputFocus (FRAME_X_DISPLAY (f
), &focus
, &revert
);
9670 if (focus
== XtWindow (f
->output_data
.x
->menubar_widget
))
9671 from_menu_bar_p
= 1;
9673 #endif /* LESSTIF_VERSION */
9675 if (event
.xcrossing
.focus
|| from_menu_bar_p
)
9676 x_mouse_leave (dpyinfo
);
9679 if (f
== dpyinfo
->x_focus_event_frame
)
9680 dpyinfo
->x_focus_event_frame
= 0;
9681 if (f
== dpyinfo
->x_focus_frame
)
9682 x_new_focus_frame (dpyinfo
, 0);
9688 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
9689 if (event
.xfocus
.detail
!= NotifyPointer
9690 && f
== dpyinfo
->x_focus_event_frame
)
9691 dpyinfo
->x_focus_event_frame
= 0;
9692 if (f
&& f
== dpyinfo
->x_focus_frame
)
9693 x_new_focus_frame (dpyinfo
, 0);
9696 if (f
&& FRAME_XIC (f
))
9697 XUnsetICFocus (FRAME_XIC (f
));
9704 previous_help_echo
= help_echo
;
9707 if (dpyinfo
->grabbed
&& last_mouse_frame
9708 && FRAME_LIVE_P (last_mouse_frame
))
9709 f
= last_mouse_frame
;
9711 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
9714 note_mouse_movement (f
, &event
.xmotion
);
9717 #ifndef USE_TOOLKIT_SCROLL_BARS
9718 struct scroll_bar
*bar
9719 = x_window_to_scroll_bar (event
.xmotion
.window
);
9722 x_scroll_bar_note_movement (bar
, &event
);
9723 #endif /* USE_TOOLKIT_SCROLL_BARS */
9725 /* If we move outside the frame, then we're
9726 certainly no longer on any text in the frame. */
9727 clear_mouse_face (dpyinfo
);
9730 /* If the contents of the global variable help_echo
9731 has changed, generate a HELP_EVENT. */
9732 if (STRINGP (help_echo
)
9733 || STRINGP (previous_help_echo
))
9738 XSETFRAME (frame
, f
);
9742 any_help_event_p
= 1;
9743 bufp
->kind
= HELP_EVENT
;
9744 bufp
->frame_or_window
= Fcons (frame
, help_echo
);
9745 ++bufp
, ++count
, --numchars
;
9751 case ConfigureNotify
:
9752 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
9755 #ifndef USE_X_TOOLKIT
9756 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
9757 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
9759 /* In the toolkit version, change_frame_size
9760 is called by the code that handles resizing
9761 of the EmacsFrame widget. */
9763 /* Even if the number of character rows and columns has
9764 not changed, the font size may have changed, so we need
9765 to check the pixel dimensions as well. */
9766 if (columns
!= f
->width
9767 || rows
!= f
->height
9768 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
9769 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
9771 change_frame_size (f
, rows
, columns
, 0, 1, 0);
9772 SET_FRAME_GARBAGED (f
);
9773 cancel_mouse_face (f
);
9777 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
9778 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
9780 /* What we have now is the position of Emacs's own window.
9781 Convert that to the position of the window manager window. */
9782 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
9783 &f
->output_data
.x
->top_pos
);
9786 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
9787 xic_set_statusarea (f
);
9790 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
9792 /* Since the WM decorations come below top_pos now,
9793 we must put them below top_pos in the future. */
9794 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
9795 x_wm_set_size_hint (f
, (long) 0, 0);
9798 /* Some window managers pass (0,0) as the location of
9799 the window, and the Motif event handler stores it
9800 in the emacs widget, which messes up Motif menus. */
9801 if (event
.xconfigure
.x
== 0 && event
.xconfigure
.y
== 0)
9803 event
.xconfigure
.x
= f
->output_data
.x
->widget
->core
.x
;
9804 event
.xconfigure
.y
= f
->output_data
.x
->widget
->core
.y
;
9806 #endif /* USE_MOTIF */
9813 /* If we decide we want to generate an event to be seen
9814 by the rest of Emacs, we put it here. */
9815 struct input_event emacs_event
;
9818 emacs_event
.kind
= no_event
;
9819 bzero (&compose_status
, sizeof (compose_status
));
9821 if (dpyinfo
->grabbed
9823 && FRAME_LIVE_P (last_mouse_frame
))
9824 f
= last_mouse_frame
;
9826 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
9830 /* Is this in the tool-bar? */
9831 if (WINDOWP (f
->tool_bar_window
)
9832 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
9837 x
= event
.xbutton
.x
;
9838 y
= event
.xbutton
.y
;
9841 window
= window_from_coordinates (f
, x
, y
, &p
, 1);
9842 if (EQ (window
, f
->tool_bar_window
))
9844 x_handle_tool_bar_click (f
, &event
.xbutton
);
9850 if (!dpyinfo
->x_focus_frame
9851 || f
== dpyinfo
->x_focus_frame
)
9852 construct_mouse_click (&emacs_event
, &event
, f
);
9856 #ifndef USE_TOOLKIT_SCROLL_BARS
9857 struct scroll_bar
*bar
9858 = x_window_to_scroll_bar (event
.xbutton
.window
);
9861 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
9862 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9865 if (event
.type
== ButtonPress
)
9867 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
9868 last_mouse_frame
= f
;
9869 /* Ignore any mouse motion that happened
9870 before this event; any subsequent mouse-movement
9871 Emacs events should reflect only motion after
9877 last_tool_bar_item
= -1;
9881 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
9884 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
9886 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
9892 #ifdef USE_X_TOOLKIT
9893 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
9894 /* For a down-event in the menu bar,
9895 don't pass it to Xt right now.
9896 Instead, save it away
9897 and we will pass it to Xt from kbd_buffer_get_event.
9898 That way, we can run some Lisp code first. */
9899 if (f
&& event
.type
== ButtonPress
9900 /* Verify the event is really within the menu bar
9901 and not just sent to it due to grabbing. */
9902 && event
.xbutton
.x
>= 0
9903 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
9904 && event
.xbutton
.y
>= 0
9905 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
9906 && event
.xbutton
.same_screen
)
9908 SET_SAVED_BUTTON_EVENT
;
9909 XSETFRAME (last_mouse_press_frame
, f
);
9911 else if (event
.type
== ButtonPress
)
9913 last_mouse_press_frame
= Qnil
;
9917 #ifdef USE_MOTIF /* This should do not harm for Lucid,
9918 but I am trying to be cautious. */
9919 else if (event
.type
== ButtonRelease
)
9921 if (!NILP (last_mouse_press_frame
))
9923 f
= XFRAME (last_mouse_press_frame
);
9924 if (f
->output_data
.x
)
9925 SET_SAVED_BUTTON_EVENT
;
9930 #endif /* USE_MOTIF */
9933 #endif /* USE_X_TOOLKIT */
9937 case CirculateNotify
:
9940 case CirculateRequest
:
9943 case VisibilityNotify
:
9947 /* Someone has changed the keyboard mapping - update the
9949 switch (event
.xmapping
.request
)
9951 case MappingModifier
:
9952 x_find_modifier_meanings (dpyinfo
);
9953 /* This is meant to fall through. */
9954 case MappingKeyboard
:
9955 XRefreshKeyboardMapping (&event
.xmapping
);
9961 #ifdef USE_X_TOOLKIT
9963 XtDispatchEvent (&event
);
9965 #endif /* USE_X_TOOLKIT */
9973 /* On some systems, an X bug causes Emacs to get no more events
9974 when the window is destroyed. Detect that. (1994.) */
9977 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
9978 One XNOOP in 100 loops will make Emacs terminate.
9979 B. Bretthauer, 1994 */
9981 if (x_noop_count
>= 100)
9985 if (next_noop_dpyinfo
== 0)
9986 next_noop_dpyinfo
= x_display_list
;
9988 XNoOp (next_noop_dpyinfo
->display
);
9990 /* Each time we get here, cycle through the displays now open. */
9991 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
9995 /* If the focus was just given to an auto-raising frame,
9997 /* ??? This ought to be able to handle more than one such frame. */
9998 if (pending_autoraise_frame
)
10000 x_raise_frame (pending_autoraise_frame
);
10001 pending_autoraise_frame
= 0;
10011 /***********************************************************************
10013 ***********************************************************************/
10015 /* Note if the text cursor of window W has been overwritten by a
10016 drawing operation that outputs N glyphs starting at HPOS in the
10017 line given by output_cursor.vpos. N < 0 means all the rest of the
10018 line after HPOS has been written. */
10021 note_overwritten_text_cursor (w
, hpos
, n
)
10025 if (updated_area
== TEXT_AREA
10026 && output_cursor
.vpos
== w
->phys_cursor
.vpos
10027 && hpos
<= w
->phys_cursor
.hpos
10029 || hpos
+ n
> w
->phys_cursor
.hpos
))
10030 w
->phys_cursor_on_p
= 0;
10034 /* Set clipping for output in glyph row ROW. W is the window in which
10035 we operate. GC is the graphics context to set clipping in.
10036 WHOLE_LINE_P non-zero means include the areas used for truncation
10037 mark display and alike in the clipping rectangle.
10039 ROW may be a text row or, e.g., a mode line. Text rows must be
10040 clipped to the interior of the window dedicated to text display,
10041 mode lines must be clipped to the whole window. */
10044 x_clip_to_row (w
, row
, gc
, whole_line_p
)
10046 struct glyph_row
*row
;
10050 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10051 XRectangle clip_rect
;
10052 int window_x
, window_y
, window_width
, window_height
;
10054 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
10056 clip_rect
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
10057 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
10058 clip_rect
.y
= max (clip_rect
.y
, window_y
);
10059 clip_rect
.width
= window_width
;
10060 clip_rect
.height
= row
->visible_height
;
10062 /* If clipping to the whole line, including trunc marks, extend
10063 the rectangle to the left and increase its width. */
10066 clip_rect
.x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
10067 clip_rect
.width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
10070 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
10074 /* Draw a hollow box cursor on window W in glyph row ROW. */
10077 x_draw_hollow_cursor (w
, row
)
10079 struct glyph_row
*row
;
10081 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10082 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10083 Display
*dpy
= FRAME_X_DISPLAY (f
);
10086 struct glyph
*cursor_glyph
;
10089 /* Compute frame-relative coordinates from window-relative
10091 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
10092 y
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
10093 + row
->ascent
- w
->phys_cursor_ascent
);
10094 h
= row
->height
- 1;
10096 /* Get the glyph the cursor is on. If we can't tell because
10097 the current matrix is invalid or such, give up. */
10098 cursor_glyph
= get_phys_cursor_glyph (w
);
10099 if (cursor_glyph
== NULL
)
10102 /* Compute the width of the rectangle to draw. If on a stretch
10103 glyph, and `x-stretch-block-cursor' is nil, don't draw a
10104 rectangle as wide as the glyph, but use a canonical character
10106 wd
= cursor_glyph
->pixel_width
- 1;
10107 if (cursor_glyph
->type
== STRETCH_GLYPH
10108 && !x_stretch_cursor_p
)
10109 wd
= min (CANON_X_UNIT (f
), wd
);
10111 /* The foreground of cursor_gc is typically the same as the normal
10112 background color, which can cause the cursor box to be invisible. */
10113 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
10114 if (dpyinfo
->scratch_cursor_gc
)
10115 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
10117 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
10118 GCForeground
, &xgcv
);
10119 gc
= dpyinfo
->scratch_cursor_gc
;
10121 /* Set clipping, draw the rectangle, and reset clipping again. */
10122 x_clip_to_row (w
, row
, gc
, 0);
10123 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
10124 XSetClipMask (dpy
, gc
, None
);
10128 /* Draw a bar cursor on window W in glyph row ROW.
10130 Implementation note: One would like to draw a bar cursor with an
10131 angle equal to the one given by the font property XA_ITALIC_ANGLE.
10132 Unfortunately, I didn't find a font yet that has this property set.
10136 x_draw_bar_cursor (w
, row
, width
)
10138 struct glyph_row
*row
;
10141 /* If cursor hpos is out of bounds, don't draw garbage. This can
10142 happen in mini-buffer windows when switching between echo area
10143 glyphs and mini-buffer. */
10144 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
10146 struct frame
*f
= XFRAME (w
->frame
);
10147 struct glyph
*cursor_glyph
;
10150 unsigned long mask
;
10155 cursor_glyph
= get_phys_cursor_glyph (w
);
10156 if (cursor_glyph
== NULL
)
10159 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
10160 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
10161 xgcv
.graphics_exposures
= 0;
10162 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
10163 dpy
= FRAME_X_DISPLAY (f
);
10164 window
= FRAME_X_WINDOW (f
);
10165 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
10168 XChangeGC (dpy
, gc
, mask
, &xgcv
);
10171 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
10172 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
10176 width
= f
->output_data
.x
->cursor_width
;
10178 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
10179 x_clip_to_row (w
, row
, gc
, 0);
10180 XFillRectangle (dpy
, window
, gc
,
10182 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
10183 min (cursor_glyph
->pixel_width
, width
),
10185 XSetClipMask (dpy
, gc
, None
);
10190 /* Clear the cursor of window W to background color, and mark the
10191 cursor as not shown. This is used when the text where the cursor
10192 is is about to be rewritten. */
10198 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
10199 x_update_window_cursor (w
, 0);
10203 /* Draw the cursor glyph of window W in glyph row ROW. See the
10204 comment of x_draw_glyphs for the meaning of HL. */
10207 x_draw_phys_cursor_glyph (w
, row
, hl
)
10209 struct glyph_row
*row
;
10210 enum draw_glyphs_face hl
;
10212 /* If cursor hpos is out of bounds, don't draw garbage. This can
10213 happen in mini-buffer windows when switching between echo area
10214 glyphs and mini-buffer. */
10215 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
10217 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
10218 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
10221 /* When we erase the cursor, and ROW is overlapped by other
10222 rows, make sure that these overlapping parts of other rows
10224 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
10226 if (row
> w
->current_matrix
->rows
10227 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
10228 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
10230 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
10231 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
10232 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
10238 /* Erase the image of a cursor of window W from the screen. */
10241 x_erase_phys_cursor (w
)
10244 struct frame
*f
= XFRAME (w
->frame
);
10245 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10246 int hpos
= w
->phys_cursor
.hpos
;
10247 int vpos
= w
->phys_cursor
.vpos
;
10248 int mouse_face_here_p
= 0;
10249 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
10250 struct glyph_row
*cursor_row
;
10251 struct glyph
*cursor_glyph
;
10252 enum draw_glyphs_face hl
;
10254 /* No cursor displayed or row invalidated => nothing to do on the
10256 if (w
->phys_cursor_type
== NO_CURSOR
)
10257 goto mark_cursor_off
;
10259 /* VPOS >= active_glyphs->nrows means that window has been resized.
10260 Don't bother to erase the cursor. */
10261 if (vpos
>= active_glyphs
->nrows
)
10262 goto mark_cursor_off
;
10264 /* If row containing cursor is marked invalid, there is nothing we
10266 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
10267 if (!cursor_row
->enabled_p
)
10268 goto mark_cursor_off
;
10270 /* This can happen when the new row is shorter than the old one.
10271 In this case, either x_draw_glyphs or clear_end_of_line
10272 should have cleared the cursor. Note that we wouldn't be
10273 able to erase the cursor in this case because we don't have a
10274 cursor glyph at hand. */
10275 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
10276 goto mark_cursor_off
;
10278 /* If the cursor is in the mouse face area, redisplay that when
10279 we clear the cursor. */
10280 if (! NILP (dpyinfo
->mouse_face_window
)
10281 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
10282 && (vpos
> dpyinfo
->mouse_face_beg_row
10283 || (vpos
== dpyinfo
->mouse_face_beg_row
10284 && hpos
>= dpyinfo
->mouse_face_beg_col
))
10285 && (vpos
< dpyinfo
->mouse_face_end_row
10286 || (vpos
== dpyinfo
->mouse_face_end_row
10287 && hpos
< dpyinfo
->mouse_face_end_col
))
10288 /* Don't redraw the cursor's spot in mouse face if it is at the
10289 end of a line (on a newline). The cursor appears there, but
10290 mouse highlighting does not. */
10291 && cursor_row
->used
[TEXT_AREA
] > hpos
)
10292 mouse_face_here_p
= 1;
10294 /* Maybe clear the display under the cursor. */
10295 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
10298 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
10300 cursor_glyph
= get_phys_cursor_glyph (w
);
10301 if (cursor_glyph
== NULL
)
10302 goto mark_cursor_off
;
10304 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
10306 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10308 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
10310 cursor_glyph
->pixel_width
,
10311 cursor_row
->visible_height
,
10315 /* Erase the cursor by redrawing the character underneath it. */
10316 if (mouse_face_here_p
)
10317 hl
= DRAW_MOUSE_FACE
;
10318 else if (cursor_row
->inverse_p
)
10319 hl
= DRAW_INVERSE_VIDEO
;
10321 hl
= DRAW_NORMAL_TEXT
;
10322 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
10325 w
->phys_cursor_on_p
= 0;
10326 w
->phys_cursor_type
= NO_CURSOR
;
10330 /* Display or clear cursor of window W. If ON is zero, clear the
10331 cursor. If it is non-zero, display the cursor. If ON is nonzero,
10332 where to put the cursor is specified by HPOS, VPOS, X and Y. */
10335 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
10337 int on
, hpos
, vpos
, x
, y
;
10339 struct frame
*f
= XFRAME (w
->frame
);
10340 int new_cursor_type
;
10341 int new_cursor_width
;
10342 struct glyph_matrix
*current_glyphs
;
10343 struct glyph_row
*glyph_row
;
10344 struct glyph
*glyph
;
10346 /* This is pointless on invisible frames, and dangerous on garbaged
10347 windows and frames; in the latter case, the frame or window may
10348 be in the midst of changing its size, and x and y may be off the
10350 if (! FRAME_VISIBLE_P (f
)
10351 || FRAME_GARBAGED_P (f
)
10352 || vpos
>= w
->current_matrix
->nrows
10353 || hpos
>= w
->current_matrix
->matrix_w
)
10356 /* If cursor is off and we want it off, return quickly. */
10357 if (!on
&& !w
->phys_cursor_on_p
)
10360 current_glyphs
= w
->current_matrix
;
10361 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
10362 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
10364 /* If cursor row is not enabled, we don't really know where to
10365 display the cursor. */
10366 if (!glyph_row
->enabled_p
)
10368 w
->phys_cursor_on_p
= 0;
10372 xassert (interrupt_input_blocked
);
10374 /* Set new_cursor_type to the cursor we want to be displayed. In a
10375 mini-buffer window, we want the cursor only to appear if we are
10376 reading input from this window. For the selected window, we want
10377 the cursor type given by the frame parameter. If explicitly
10378 marked off, draw no cursor. In all other cases, we want a hollow
10380 new_cursor_width
= -1;
10381 if (cursor_in_echo_area
10382 && FRAME_HAS_MINIBUF_P (f
)
10383 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
10385 if (w
== XWINDOW (echo_area_window
))
10386 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
10388 new_cursor_type
= HOLLOW_BOX_CURSOR
;
10392 if (w
!= XWINDOW (selected_window
)
10393 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
10395 extern int cursor_in_non_selected_windows
;
10397 if (MINI_WINDOW_P (w
) || !cursor_in_non_selected_windows
)
10398 new_cursor_type
= NO_CURSOR
;
10400 new_cursor_type
= HOLLOW_BOX_CURSOR
;
10402 else if (w
->cursor_off_p
)
10403 new_cursor_type
= NO_CURSOR
;
10406 struct buffer
*b
= XBUFFER (w
->buffer
);
10408 if (EQ (b
->cursor_type
, Qt
))
10409 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
10411 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
10412 &new_cursor_width
);
10416 /* If cursor is currently being shown and we don't want it to be or
10417 it is in the wrong place, or the cursor type is not what we want,
10419 if (w
->phys_cursor_on_p
10421 || w
->phys_cursor
.x
!= x
10422 || w
->phys_cursor
.y
!= y
10423 || new_cursor_type
!= w
->phys_cursor_type
))
10424 x_erase_phys_cursor (w
);
10426 /* If the cursor is now invisible and we want it to be visible,
10428 if (on
&& !w
->phys_cursor_on_p
)
10430 w
->phys_cursor_ascent
= glyph_row
->ascent
;
10431 w
->phys_cursor_height
= glyph_row
->height
;
10433 /* Set phys_cursor_.* before x_draw_.* is called because some
10434 of them may need the information. */
10435 w
->phys_cursor
.x
= x
;
10436 w
->phys_cursor
.y
= glyph_row
->y
;
10437 w
->phys_cursor
.hpos
= hpos
;
10438 w
->phys_cursor
.vpos
= vpos
;
10439 w
->phys_cursor_type
= new_cursor_type
;
10440 w
->phys_cursor_on_p
= 1;
10442 switch (new_cursor_type
)
10444 case HOLLOW_BOX_CURSOR
:
10445 x_draw_hollow_cursor (w
, glyph_row
);
10448 case FILLED_BOX_CURSOR
:
10449 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
10453 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
);
10464 if (w
== XWINDOW (f
->selected_window
))
10465 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
10466 xic_set_preeditarea (w
, x
, y
);
10471 if (updating_frame
!= f
)
10472 XFlush (FRAME_X_DISPLAY (f
));
10477 /* Display the cursor on window W, or clear it. X and Y are window
10478 relative pixel coordinates. HPOS and VPOS are glyph matrix
10479 positions. If W is not the selected window, display a hollow
10480 cursor. ON non-zero means display the cursor at X, Y which
10481 correspond to HPOS, VPOS, otherwise it is cleared. */
10484 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
10486 int on
, hpos
, vpos
, x
, y
;
10489 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
10494 /* Display the cursor on window W, or clear it, according to ON_P.
10495 Don't change the cursor's position. */
10498 x_update_cursor (f
, on_p
)
10501 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
10505 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
10506 in the window tree rooted at W. */
10509 x_update_cursor_in_window_tree (w
, on_p
)
10515 if (!NILP (w
->hchild
))
10516 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
10517 else if (!NILP (w
->vchild
))
10518 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
10520 x_update_window_cursor (w
, on_p
);
10522 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
10527 /* Switch the display of W's cursor on or off, according to the value
10531 x_update_window_cursor (w
, on
)
10535 /* Don't update cursor in windows whose frame is in the process
10536 of being deleted. */
10537 if (w
->current_matrix
)
10540 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
10541 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
10551 /* Refresh bitmap kitchen sink icon for frame F
10552 when we get an expose event for it. */
10558 /* Normally, the window manager handles this function. */
10561 /* Make the x-window of frame F use the gnu icon bitmap. */
10564 x_bitmap_icon (f
, file
)
10570 if (FRAME_X_WINDOW (f
) == 0)
10573 /* Free up our existing icon bitmap if any. */
10574 if (f
->output_data
.x
->icon_bitmap
> 0)
10575 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
10576 f
->output_data
.x
->icon_bitmap
= 0;
10578 if (STRINGP (file
))
10579 bitmap_id
= x_create_bitmap_from_file (f
, file
);
10582 /* Create the GNU bitmap if necessary. */
10583 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
10584 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
10585 = x_create_bitmap_from_data (f
, gnu_bits
,
10586 gnu_width
, gnu_height
);
10588 /* The first time we create the GNU bitmap,
10589 this increments the ref-count one extra time.
10590 As a result, the GNU bitmap is never freed.
10591 That way, we don't have to worry about allocating it again. */
10592 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
10594 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
10597 x_wm_set_icon_pixmap (f
, bitmap_id
);
10598 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
10604 /* Make the x-window of frame F use a rectangle with text.
10605 Use ICON_NAME as the text. */
10608 x_text_icon (f
, icon_name
)
10612 if (FRAME_X_WINDOW (f
) == 0)
10617 XTextProperty text
;
10618 text
.value
= (unsigned char *) icon_name
;
10619 text
.encoding
= XA_STRING
;
10621 text
.nitems
= strlen (icon_name
);
10622 #ifdef USE_X_TOOLKIT
10623 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
10625 #else /* not USE_X_TOOLKIT */
10626 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
10627 #endif /* not USE_X_TOOLKIT */
10629 #else /* not HAVE_X11R4 */
10630 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
10631 #endif /* not HAVE_X11R4 */
10633 if (f
->output_data
.x
->icon_bitmap
> 0)
10634 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
10635 f
->output_data
.x
->icon_bitmap
= 0;
10636 x_wm_set_icon_pixmap (f
, 0);
10641 #define X_ERROR_MESSAGE_SIZE 200
10643 /* If non-nil, this should be a string.
10644 It means catch X errors and store the error message in this string. */
10646 static Lisp_Object x_error_message_string
;
10648 /* An X error handler which stores the error message in
10649 x_error_message_string. This is called from x_error_handler if
10650 x_catch_errors is in effect. */
10653 x_error_catcher (display
, error
)
10655 XErrorEvent
*error
;
10657 XGetErrorText (display
, error
->error_code
,
10658 XSTRING (x_error_message_string
)->data
,
10659 X_ERROR_MESSAGE_SIZE
);
10662 /* Begin trapping X errors for display DPY. Actually we trap X errors
10663 for all displays, but DPY should be the display you are actually
10666 After calling this function, X protocol errors no longer cause
10667 Emacs to exit; instead, they are recorded in the string
10668 stored in x_error_message_string.
10670 Calling x_check_errors signals an Emacs error if an X error has
10671 occurred since the last call to x_catch_errors or x_check_errors.
10673 Calling x_uncatch_errors resumes the normal error handling. */
10675 void x_check_errors ();
10676 static Lisp_Object
x_catch_errors_unwind ();
10679 x_catch_errors (dpy
)
10682 int count
= specpdl_ptr
- specpdl
;
10684 /* Make sure any errors from previous requests have been dealt with. */
10685 XSync (dpy
, False
);
10687 record_unwind_protect (x_catch_errors_unwind
, x_error_message_string
);
10689 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
10690 XSTRING (x_error_message_string
)->data
[0] = 0;
10695 /* Unbind the binding that we made to check for X errors. */
10698 x_catch_errors_unwind (old_val
)
10699 Lisp_Object old_val
;
10701 x_error_message_string
= old_val
;
10705 /* If any X protocol errors have arrived since the last call to
10706 x_catch_errors or x_check_errors, signal an Emacs error using
10707 sprintf (a buffer, FORMAT, the x error message text) as the text. */
10710 x_check_errors (dpy
, format
)
10714 /* Make sure to catch any errors incurred so far. */
10715 XSync (dpy
, False
);
10717 if (XSTRING (x_error_message_string
)->data
[0])
10718 error (format
, XSTRING (x_error_message_string
)->data
);
10721 /* Nonzero if we had any X protocol errors
10722 since we did x_catch_errors on DPY. */
10725 x_had_errors_p (dpy
)
10728 /* Make sure to catch any errors incurred so far. */
10729 XSync (dpy
, False
);
10731 return XSTRING (x_error_message_string
)->data
[0] != 0;
10734 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
10737 x_clear_errors (dpy
)
10740 XSTRING (x_error_message_string
)->data
[0] = 0;
10743 /* Stop catching X protocol errors and let them make Emacs die.
10744 DPY should be the display that was passed to x_catch_errors.
10745 COUNT should be the value that was returned by
10746 the corresponding call to x_catch_errors. */
10749 x_uncatch_errors (dpy
, count
)
10753 unbind_to (count
, Qnil
);
10757 static unsigned int x_wire_count
;
10760 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
10765 /* Handle SIGPIPE, which can happen when the connection to a server
10766 simply goes away. SIGPIPE is handled by x_connection_signal.
10767 Don't need to do anything, because the write which caused the
10768 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
10769 which will do the appropriate cleanup for us. */
10772 x_connection_signal (signalnum
) /* If we don't have an argument, */
10773 int signalnum
; /* some compilers complain in signal calls. */
10776 /* USG systems forget handlers when they are used;
10777 must reestablish each time */
10778 signal (signalnum
, x_connection_signal
);
10782 /* Handling X errors. */
10784 /* Handle the loss of connection to display DISPLAY. */
10787 x_connection_closed (display
, error_message
)
10789 char *error_message
;
10791 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
10792 Lisp_Object frame
, tail
;
10794 /* Indicate that this display is dead. */
10796 #if 0 /* Closing the display caused a bus error on OpenWindows. */
10797 #ifdef USE_X_TOOLKIT
10798 XtCloseDisplay (display
);
10803 dpyinfo
->display
= 0;
10805 /* First delete frames whose mini-buffers are on frames
10806 that are on the dead display. */
10807 FOR_EACH_FRAME (tail
, frame
)
10809 Lisp_Object minibuf_frame
;
10811 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
10812 if (FRAME_X_P (XFRAME (frame
))
10813 && FRAME_X_P (XFRAME (minibuf_frame
))
10814 && ! EQ (frame
, minibuf_frame
)
10815 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
10816 Fdelete_frame (frame
, Qt
);
10819 /* Now delete all remaining frames on the dead display.
10820 We are now sure none of these is used as the mini-buffer
10821 for another frame that we need to delete. */
10822 FOR_EACH_FRAME (tail
, frame
)
10823 if (FRAME_X_P (XFRAME (frame
))
10824 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
10826 /* Set this to t so that Fdelete_frame won't get confused
10827 trying to find a replacement. */
10828 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
10829 Fdelete_frame (frame
, Qt
);
10833 x_delete_display (dpyinfo
);
10835 if (x_display_list
== 0)
10837 fprintf (stderr
, "%s\n", error_message
);
10838 shut_down_emacs (0, 0, Qnil
);
10842 /* Ordinary stack unwind doesn't deal with these. */
10844 sigunblock (sigmask (SIGIO
));
10846 sigunblock (sigmask (SIGALRM
));
10847 TOTALLY_UNBLOCK_INPUT
;
10849 clear_waiting_for_input ();
10850 error ("%s", error_message
);
10853 /* This is the usual handler for X protocol errors.
10854 It kills all frames on the display that we got the error for.
10855 If that was the only one, it prints an error message and kills Emacs. */
10858 x_error_quitter (display
, error
)
10860 XErrorEvent
*error
;
10862 char buf
[256], buf1
[356];
10864 /* Note that there is no real way portable across R3/R4 to get the
10865 original error handler. */
10867 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
10868 sprintf (buf1
, "X protocol error: %s on protocol request %d",
10869 buf
, error
->request_code
);
10870 x_connection_closed (display
, buf1
);
10873 /* This is the first-level handler for X protocol errors.
10874 It calls x_error_quitter or x_error_catcher. */
10877 x_error_handler (display
, error
)
10879 XErrorEvent
*error
;
10881 if (! NILP (x_error_message_string
))
10882 x_error_catcher (display
, error
);
10884 x_error_quitter (display
, error
);
10888 /* This is the handler for X IO errors, always.
10889 It kills all frames on the display that we lost touch with.
10890 If that was the only one, it prints an error message and kills Emacs. */
10893 x_io_error_quitter (display
)
10898 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
10899 x_connection_closed (display
, buf
);
10903 /* Changing the font of the frame. */
10905 /* Give frame F the font named FONTNAME as its default font, and
10906 return the full name of that font. FONTNAME may be a wildcard
10907 pattern; in that case, we choose some font that fits the pattern.
10908 The return value shows which font we chose. */
10911 x_new_font (f
, fontname
)
10913 register char *fontname
;
10915 struct font_info
*fontp
10916 = FS_LOAD_FONT (f
, 0, fontname
, -1);
10921 f
->output_data
.x
->font
= (XFontStruct
*) (fontp
->font
);
10922 f
->output_data
.x
->baseline_offset
= fontp
->baseline_offset
;
10923 f
->output_data
.x
->fontset
= -1;
10925 /* Compute the scroll bar width in character columns. */
10926 if (f
->scroll_bar_pixel_width
> 0)
10928 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
10929 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
10933 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
10934 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
10937 /* Now make the frame display the given font. */
10938 if (FRAME_X_WINDOW (f
) != 0)
10940 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
10941 f
->output_data
.x
->font
->fid
);
10942 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
10943 f
->output_data
.x
->font
->fid
);
10944 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
10945 f
->output_data
.x
->font
->fid
);
10947 frame_update_line_height (f
);
10948 x_set_window_size (f
, 0, f
->width
, f
->height
);
10951 /* If we are setting a new frame's font for the first time,
10952 there are no faces yet, so this font's height is the line height. */
10953 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
10955 return build_string (fontp
->full_name
);
10958 /* Give frame F the fontset named FONTSETNAME as its default font, and
10959 return the full name of that fontset. FONTSETNAME may be a wildcard
10960 pattern; in that case, we choose some fontset that fits the pattern.
10961 The return value shows which fontset we chose. */
10964 x_new_fontset (f
, fontsetname
)
10968 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
10969 Lisp_Object result
;
10975 if (f
->output_data
.x
->fontset
== fontset
)
10976 /* This fontset is already set in frame F. There's nothing more
10978 return fontset_name (fontset
);
10980 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
10982 if (!STRINGP (result
))
10983 /* Can't load ASCII font. */
10986 /* Since x_new_font doesn't update any fontset information, do it now. */
10987 f
->output_data
.x
->fontset
= fontset
;
10991 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
10992 xic_set_xfontset (f
, XSTRING (fontset_ascii (fontset
))->data
);
10995 return build_string (fontsetname
);
10999 /***********************************************************************
11001 ***********************************************************************/
11007 /* XIM destroy callback function, which is called whenever the
11008 connection to input method XIM dies. CLIENT_DATA contains a
11009 pointer to the x_display_info structure corresponding to XIM. */
11012 xim_destroy_callback (xim
, client_data
, call_data
)
11014 XPointer client_data
;
11015 XPointer call_data
;
11017 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
11018 Lisp_Object frame
, tail
;
11022 /* No need to call XDestroyIC.. */
11023 FOR_EACH_FRAME (tail
, frame
)
11025 struct frame
*f
= XFRAME (frame
);
11026 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
11028 FRAME_XIC (f
) = NULL
;
11029 if (FRAME_XIC_FONTSET (f
))
11031 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
11032 FRAME_XIC_FONTSET (f
) = NULL
;
11037 /* No need to call XCloseIM. */
11038 dpyinfo
->xim
= NULL
;
11039 XFree (dpyinfo
->xim_styles
);
11043 #endif /* HAVE_X11R6 */
11045 /* Open the connection to the XIM server on display DPYINFO.
11046 RESOURCE_NAME is the resource name Emacs uses. */
11049 xim_open_dpy (dpyinfo
, resource_name
)
11050 struct x_display_info
*dpyinfo
;
11051 char *resource_name
;
11055 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
, EMACS_CLASS
);
11056 dpyinfo
->xim
= xim
;
11061 XIMCallback destroy
;
11064 /* Get supported styles and XIM values. */
11065 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
11068 destroy
.callback
= xim_destroy_callback
;
11069 destroy
.client_data
= (XPointer
)dpyinfo
;
11070 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
11076 #ifdef HAVE_X11R6_XIM
11080 struct x_display_info
*dpyinfo
;
11081 char *resource_name
;
11084 /* XIM instantiate callback function, which is called whenever an XIM
11085 server is available. DISPLAY is teh display of the XIM.
11086 CLIENT_DATA contains a pointer to an xim_inst_t structure created
11087 when the callback was registered. */
11090 xim_instantiate_callback (display
, client_data
, call_data
)
11092 XPointer client_data
;
11093 XPointer call_data
;
11095 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
11096 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
11098 /* We don't support multiple XIM connections. */
11102 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
11104 /* Create XIC for the existing frames on the same display, as long
11105 as they have no XIC. */
11106 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
11108 Lisp_Object tail
, frame
;
11111 FOR_EACH_FRAME (tail
, frame
)
11113 struct frame
*f
= XFRAME (frame
);
11115 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
11116 if (FRAME_XIC (f
) == NULL
)
11118 create_frame_xic (f
);
11119 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
11120 xic_set_statusarea (f
);
11121 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
11123 struct window
*w
= XWINDOW (f
->selected_window
);
11124 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
11133 #endif /* HAVE_X11R6_XIM */
11136 /* Open a connection to the XIM server on display DPYINFO.
11137 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
11138 connection only at the first time. On X11R6, open the connection
11139 in the XIM instantiate callback function. */
11142 xim_initialize (dpyinfo
, resource_name
)
11143 struct x_display_info
*dpyinfo
;
11144 char *resource_name
;
11146 #ifdef HAVE_X11R6_XIM
11147 struct xim_inst_t
*xim_inst
;
11150 dpyinfo
->xim
= NULL
;
11151 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
11152 xim_inst
->dpyinfo
= dpyinfo
;
11153 len
= strlen (resource_name
);
11154 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
11155 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
11156 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
11157 resource_name
, EMACS_CLASS
,
11158 xim_instantiate_callback
,
11159 /* Fixme: This is XPointer in
11160 XFree86 but (XPointer *) on
11161 Tru64, at least. */
11162 (XPointer
) xim_inst
);
11163 #else /* not HAVE_X11R6_XIM */
11164 dpyinfo
->xim
= NULL
;
11165 xim_open_dpy (dpyinfo
, resource_name
);
11166 #endif /* not HAVE_X11R6_XIM */
11170 /* Close the connection to the XIM server on display DPYINFO. */
11173 xim_close_dpy (dpyinfo
)
11174 struct x_display_info
*dpyinfo
;
11176 #ifdef HAVE_X11R6_XIM
11177 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
11179 xim_instantiate_callback
, NULL
);
11180 #endif /* not HAVE_X11R6_XIM */
11181 XCloseIM (dpyinfo
->xim
);
11182 dpyinfo
->xim
= NULL
;
11183 XFree (dpyinfo
->xim_styles
);
11186 #endif /* not HAVE_X11R6_XIM */
11190 /* Calculate the absolute position in frame F
11191 from its current recorded position values and gravity. */
11194 x_calc_absolute_position (f
)
11198 int win_x
= 0, win_y
= 0;
11199 int flags
= f
->output_data
.x
->size_hint_flags
;
11202 /* We have nothing to do if the current position
11203 is already for the top-left corner. */
11204 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
11207 #ifdef USE_X_TOOLKIT
11208 this_window
= XtWindow (f
->output_data
.x
->widget
);
11210 this_window
= FRAME_X_WINDOW (f
);
11213 /* Find the position of the outside upper-left corner of
11214 the inner window, with respect to the outer window.
11215 But do this only if we will need the results. */
11216 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
11221 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
11224 x_clear_errors (FRAME_X_DISPLAY (f
));
11225 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
11227 /* From-window, to-window. */
11229 f
->output_data
.x
->parent_desc
,
11231 /* From-position, to-position. */
11232 0, 0, &win_x
, &win_y
,
11234 /* Child of win. */
11236 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
11238 Window newroot
, newparent
= 0xdeadbeef;
11239 Window
*newchildren
;
11240 unsigned int nchildren
;
11242 if (! XQueryTree (FRAME_X_DISPLAY (f
), this_window
, &newroot
,
11243 &newparent
, &newchildren
, &nchildren
))
11246 XFree ((char *) newchildren
);
11248 f
->output_data
.x
->parent_desc
= newparent
;
11254 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
11258 /* Treat negative positions as relative to the leftmost bottommost
11259 position that fits on the screen. */
11260 if (flags
& XNegative
)
11261 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
11262 - 2 * f
->output_data
.x
->border_width
- win_x
11264 + f
->output_data
.x
->left_pos
);
11266 if (flags
& YNegative
)
11268 int menubar_height
= 0;
11270 #ifdef USE_X_TOOLKIT
11271 if (f
->output_data
.x
->menubar_widget
)
11273 = (f
->output_data
.x
->menubar_widget
->core
.height
11274 + f
->output_data
.x
->menubar_widget
->core
.border_width
);
11277 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
11278 - 2 * f
->output_data
.x
->border_width
11282 + f
->output_data
.x
->top_pos
);
11285 /* The left_pos and top_pos
11286 are now relative to the top and left screen edges,
11287 so the flags should correspond. */
11288 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
11291 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
11292 to really change the position, and 0 when calling from
11293 x_make_frame_visible (in that case, XOFF and YOFF are the current
11294 position values). It is -1 when calling from x_set_frame_parameters,
11295 which means, do adjust for borders but don't change the gravity. */
11298 x_set_offset (f
, xoff
, yoff
, change_gravity
)
11300 register int xoff
, yoff
;
11301 int change_gravity
;
11303 int modified_top
, modified_left
;
11305 if (change_gravity
> 0)
11307 f
->output_data
.x
->top_pos
= yoff
;
11308 f
->output_data
.x
->left_pos
= xoff
;
11309 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
11311 f
->output_data
.x
->size_hint_flags
|= XNegative
;
11313 f
->output_data
.x
->size_hint_flags
|= YNegative
;
11314 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11316 x_calc_absolute_position (f
);
11319 x_wm_set_size_hint (f
, (long) 0, 0);
11321 modified_left
= f
->output_data
.x
->left_pos
;
11322 modified_top
= f
->output_data
.x
->top_pos
;
11323 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
11324 this seems to be unnecessary and incorrect. rms, 4/17/97. */
11325 /* It is a mystery why we need to add the border_width here
11326 when the frame is already visible, but experiment says we do. */
11327 if (change_gravity
!= 0)
11329 modified_left
+= f
->output_data
.x
->border_width
;
11330 modified_top
+= f
->output_data
.x
->border_width
;
11334 #ifdef USE_X_TOOLKIT
11335 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
11336 modified_left
, modified_top
);
11337 #else /* not USE_X_TOOLKIT */
11338 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11339 modified_left
, modified_top
);
11340 #endif /* not USE_X_TOOLKIT */
11344 /* Call this to change the size of frame F's x-window.
11345 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
11346 for this size change and subsequent size changes.
11347 Otherwise we leave the window gravity unchanged. */
11350 x_set_window_size (f
, change_gravity
, cols
, rows
)
11352 int change_gravity
;
11355 #ifndef USE_X_TOOLKIT
11356 int pixelwidth
, pixelheight
;
11361 #ifdef USE_X_TOOLKIT
11363 /* The x and y position of the widget is clobbered by the
11364 call to XtSetValues within EmacsFrameSetCharSize.
11365 This is a real kludge, but I don't understand Xt so I can't
11366 figure out a correct fix. Can anyone else tell me? -- rms. */
11367 int xpos
= f
->output_data
.x
->widget
->core
.x
;
11368 int ypos
= f
->output_data
.x
->widget
->core
.y
;
11369 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
11370 f
->output_data
.x
->widget
->core
.x
= xpos
;
11371 f
->output_data
.x
->widget
->core
.y
= ypos
;
11374 #else /* not USE_X_TOOLKIT */
11376 check_frame_size (f
, &rows
, &cols
);
11377 f
->output_data
.x
->vertical_scroll_bar_extra
11378 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
11380 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
11381 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
11382 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
11383 f
->output_data
.x
->flags_areas_extra
11384 = FRAME_FLAGS_AREA_WIDTH (f
);
11385 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
11386 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
11388 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11389 x_wm_set_size_hint (f
, (long) 0, 0);
11391 XSync (FRAME_X_DISPLAY (f
), False
);
11392 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11393 pixelwidth
, pixelheight
);
11395 /* Now, strictly speaking, we can't be sure that this is accurate,
11396 but the window manager will get around to dealing with the size
11397 change request eventually, and we'll hear how it went when the
11398 ConfigureNotify event gets here.
11400 We could just not bother storing any of this information here,
11401 and let the ConfigureNotify event set everything up, but that
11402 might be kind of confusing to the Lisp code, since size changes
11403 wouldn't be reported in the frame parameters until some random
11404 point in the future when the ConfigureNotify event arrives.
11406 We pass 1 for DELAY since we can't run Lisp code inside of
11408 change_frame_size (f
, rows
, cols
, 0, 1, 0);
11409 PIXEL_WIDTH (f
) = pixelwidth
;
11410 PIXEL_HEIGHT (f
) = pixelheight
;
11412 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
11413 receive in the ConfigureNotify event; if we get what we asked
11414 for, then the event won't cause the screen to become garbaged, so
11415 we have to make sure to do it here. */
11416 SET_FRAME_GARBAGED (f
);
11418 XFlush (FRAME_X_DISPLAY (f
));
11420 #endif /* not USE_X_TOOLKIT */
11422 /* If cursor was outside the new size, mark it as off. */
11423 mark_window_cursors_off (XWINDOW (f
->root_window
));
11425 /* Clear out any recollection of where the mouse highlighting was,
11426 since it might be in a place that's outside the new frame size.
11427 Actually checking whether it is outside is a pain in the neck,
11428 so don't try--just let the highlighting be done afresh with new size. */
11429 cancel_mouse_face (f
);
11434 /* Mouse warping. */
11437 x_set_mouse_position (f
, x
, y
)
11443 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
11444 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
11446 if (pix_x
< 0) pix_x
= 0;
11447 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
11449 if (pix_y
< 0) pix_y
= 0;
11450 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
11454 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
11455 0, 0, 0, 0, pix_x
, pix_y
);
11459 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
11462 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
11468 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
11469 0, 0, 0, 0, pix_x
, pix_y
);
11473 /* focus shifting, raising and lowering. */
11476 x_focus_on_frame (f
)
11479 #if 0 /* This proves to be unpleasant. */
11483 /* I don't think that the ICCCM allows programs to do things like this
11484 without the interaction of the window manager. Whatever you end up
11485 doing with this code, do it to x_unfocus_frame too. */
11486 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11487 RevertToPointerRoot
, CurrentTime
);
11492 x_unfocus_frame (f
)
11496 /* Look at the remarks in x_focus_on_frame. */
11497 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
11498 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
11499 RevertToPointerRoot
, CurrentTime
);
11503 /* Raise frame F. */
11509 if (f
->async_visible
)
11512 #ifdef USE_X_TOOLKIT
11513 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
11514 #else /* not USE_X_TOOLKIT */
11515 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11516 #endif /* not USE_X_TOOLKIT */
11517 XFlush (FRAME_X_DISPLAY (f
));
11522 /* Lower frame F. */
11528 if (f
->async_visible
)
11531 #ifdef USE_X_TOOLKIT
11532 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
11533 #else /* not USE_X_TOOLKIT */
11534 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11535 #endif /* not USE_X_TOOLKIT */
11536 XFlush (FRAME_X_DISPLAY (f
));
11542 XTframe_raise_lower (f
, raise_flag
)
11552 /* Change of visibility. */
11554 /* This tries to wait until the frame is really visible.
11555 However, if the window manager asks the user where to position
11556 the frame, this will return before the user finishes doing that.
11557 The frame will not actually be visible at that time,
11558 but it will become visible later when the window manager
11559 finishes with it. */
11562 x_make_frame_visible (f
)
11566 int original_top
, original_left
;
11570 type
= x_icon_type (f
);
11572 x_bitmap_icon (f
, type
);
11574 if (! FRAME_VISIBLE_P (f
))
11576 /* We test FRAME_GARBAGED_P here to make sure we don't
11577 call x_set_offset a second time
11578 if we get to x_make_frame_visible a second time
11579 before the window gets really visible. */
11580 if (! FRAME_ICONIFIED_P (f
)
11581 && ! f
->output_data
.x
->asked_for_visible
)
11582 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
11584 f
->output_data
.x
->asked_for_visible
= 1;
11586 if (! EQ (Vx_no_window_manager
, Qt
))
11587 x_wm_set_window_state (f
, NormalState
);
11588 #ifdef USE_X_TOOLKIT
11589 /* This was XtPopup, but that did nothing for an iconified frame. */
11590 XtMapWidget (f
->output_data
.x
->widget
);
11591 #else /* not USE_X_TOOLKIT */
11592 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11593 #endif /* not USE_X_TOOLKIT */
11594 #if 0 /* This seems to bring back scroll bars in the wrong places
11595 if the window configuration has changed. They seem
11596 to come back ok without this. */
11597 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
11598 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11602 XFlush (FRAME_X_DISPLAY (f
));
11604 /* Synchronize to ensure Emacs knows the frame is visible
11605 before we do anything else. We do this loop with input not blocked
11606 so that incoming events are handled. */
11610 /* This must be before UNBLOCK_INPUT
11611 since events that arrive in response to the actions above
11612 will set it when they are handled. */
11613 int previously_visible
= f
->output_data
.x
->has_been_visible
;
11615 original_left
= f
->output_data
.x
->left_pos
;
11616 original_top
= f
->output_data
.x
->top_pos
;
11618 /* This must come after we set COUNT. */
11621 /* We unblock here so that arriving X events are processed. */
11623 /* Now move the window back to where it was "supposed to be".
11624 But don't do it if the gravity is negative.
11625 When the gravity is negative, this uses a position
11626 that is 3 pixels too low. Perhaps that's really the border width.
11628 Don't do this if the window has never been visible before,
11629 because the window manager may choose the position
11630 and we don't want to override it. */
11632 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
11633 && f
->output_data
.x
->win_gravity
== NorthWestGravity
11634 && previously_visible
)
11638 unsigned int width
, height
, border
, depth
;
11642 /* On some window managers (such as FVWM) moving an existing
11643 window, even to the same place, causes the window manager
11644 to introduce an offset. This can cause the window to move
11645 to an unexpected location. Check the geometry (a little
11646 slow here) and then verify that the window is in the right
11647 place. If the window is not in the right place, move it
11648 there, and take the potential window manager hit. */
11649 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
11650 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
11652 if (original_left
!= x
|| original_top
!= y
)
11653 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
11654 original_left
, original_top
);
11659 XSETFRAME (frame
, f
);
11661 /* Wait until the frame is visible. Process X events until a
11662 MapNotify event has been seen, or until we think we won't get a
11663 MapNotify at all.. */
11664 for (count
= input_signal_count
+ 10;
11665 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
11667 /* Force processing of queued events. */
11670 /* Machines that do polling rather than SIGIO have been
11671 observed to go into a busy-wait here. So we'll fake an
11672 alarm signal to let the handler know that there's something
11673 to be read. We used to raise a real alarm, but it seems
11674 that the handler isn't always enabled here. This is
11676 if (input_polling_used ())
11678 /* It could be confusing if a real alarm arrives while
11679 processing the fake one. Turn it off and let the
11680 handler reset it. */
11681 int old_poll_suppress_count
= poll_suppress_count
;
11682 poll_suppress_count
= 1;
11683 poll_for_input_1 ();
11684 poll_suppress_count
= old_poll_suppress_count
;
11687 /* See if a MapNotify event has been processed. */
11688 FRAME_SAMPLE_VISIBILITY (f
);
11693 /* Change from mapped state to withdrawn state. */
11695 /* Make the frame visible (mapped and not iconified). */
11698 x_make_frame_invisible (f
)
11703 #ifdef USE_X_TOOLKIT
11704 /* Use the frame's outermost window, not the one we normally draw on. */
11705 window
= XtWindow (f
->output_data
.x
->widget
);
11706 #else /* not USE_X_TOOLKIT */
11707 window
= FRAME_X_WINDOW (f
);
11708 #endif /* not USE_X_TOOLKIT */
11710 /* Don't keep the highlight on an invisible frame. */
11711 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
11712 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
11714 #if 0/* This might add unreliability; I don't trust it -- rms. */
11715 if (! f
->async_visible
&& ! f
->async_iconified
)
11721 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
11722 that the current position of the window is user-specified, rather than
11723 program-specified, so that when the window is mapped again, it will be
11724 placed at the same location, without forcing the user to position it
11725 by hand again (they have already done that once for this window.) */
11726 x_wm_set_size_hint (f
, (long) 0, 1);
11730 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
11731 DefaultScreen (FRAME_X_DISPLAY (f
))))
11733 UNBLOCK_INPUT_RESIGNAL
;
11734 error ("Can't notify window manager of window withdrawal");
11736 #else /* ! defined (HAVE_X11R4) */
11738 /* Tell the window manager what we're going to do. */
11739 if (! EQ (Vx_no_window_manager
, Qt
))
11743 unmap
.xunmap
.type
= UnmapNotify
;
11744 unmap
.xunmap
.window
= window
;
11745 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
11746 unmap
.xunmap
.from_configure
= False
;
11747 if (! XSendEvent (FRAME_X_DISPLAY (f
),
11748 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
11750 SubstructureRedirectMaskSubstructureNotifyMask
,
11753 UNBLOCK_INPUT_RESIGNAL
;
11754 error ("Can't notify window manager of withdrawal");
11758 /* Unmap the window ourselves. Cheeky! */
11759 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
11760 #endif /* ! defined (HAVE_X11R4) */
11762 /* We can't distinguish this from iconification
11763 just by the event that we get from the server.
11764 So we can't win using the usual strategy of letting
11765 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
11766 and synchronize with the server to make sure we agree. */
11768 FRAME_ICONIFIED_P (f
) = 0;
11769 f
->async_visible
= 0;
11770 f
->async_iconified
= 0;
11777 /* Change window state from mapped to iconified. */
11780 x_iconify_frame (f
)
11786 /* Don't keep the highlight on an invisible frame. */
11787 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
11788 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
11790 if (f
->async_iconified
)
11795 FRAME_SAMPLE_VISIBILITY (f
);
11797 type
= x_icon_type (f
);
11799 x_bitmap_icon (f
, type
);
11801 #ifdef USE_X_TOOLKIT
11803 if (! FRAME_VISIBLE_P (f
))
11805 if (! EQ (Vx_no_window_manager
, Qt
))
11806 x_wm_set_window_state (f
, IconicState
);
11807 /* This was XtPopup, but that did nothing for an iconified frame. */
11808 XtMapWidget (f
->output_data
.x
->widget
);
11809 /* The server won't give us any event to indicate
11810 that an invisible frame was changed to an icon,
11811 so we have to record it here. */
11814 f
->async_iconified
= 1;
11815 f
->async_visible
= 0;
11820 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
11821 XtWindow (f
->output_data
.x
->widget
),
11822 DefaultScreen (FRAME_X_DISPLAY (f
)));
11826 error ("Can't notify window manager of iconification");
11828 f
->async_iconified
= 1;
11829 f
->async_visible
= 0;
11833 XFlush (FRAME_X_DISPLAY (f
));
11835 #else /* not USE_X_TOOLKIT */
11837 /* Make sure the X server knows where the window should be positioned,
11838 in case the user deiconifies with the window manager. */
11839 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
11840 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
11842 /* Since we don't know which revision of X we're running, we'll use both
11843 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
11845 /* X11R4: send a ClientMessage to the window manager using the
11846 WM_CHANGE_STATE type. */
11850 message
.xclient
.window
= FRAME_X_WINDOW (f
);
11851 message
.xclient
.type
= ClientMessage
;
11852 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
11853 message
.xclient
.format
= 32;
11854 message
.xclient
.data
.l
[0] = IconicState
;
11856 if (! XSendEvent (FRAME_X_DISPLAY (f
),
11857 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
11859 SubstructureRedirectMask
| SubstructureNotifyMask
,
11862 UNBLOCK_INPUT_RESIGNAL
;
11863 error ("Can't notify window manager of iconification");
11867 /* X11R3: set the initial_state field of the window manager hints to
11869 x_wm_set_window_state (f
, IconicState
);
11871 if (!FRAME_VISIBLE_P (f
))
11873 /* If the frame was withdrawn, before, we must map it. */
11874 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11877 f
->async_iconified
= 1;
11878 f
->async_visible
= 0;
11880 XFlush (FRAME_X_DISPLAY (f
));
11882 #endif /* not USE_X_TOOLKIT */
11885 /* Destroy the X window of frame F. */
11888 x_destroy_window (f
)
11891 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11895 /* If a display connection is dead, don't try sending more
11896 commands to the X server. */
11897 if (dpyinfo
->display
!= 0)
11899 if (f
->output_data
.x
->icon_desc
!= 0)
11900 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
11903 free_frame_xic (f
);
11905 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->window_desc
);
11906 #ifdef USE_X_TOOLKIT
11907 if (f
->output_data
.x
->widget
)
11908 XtDestroyWidget (f
->output_data
.x
->widget
);
11909 free_frame_menubar (f
);
11910 #endif /* USE_X_TOOLKIT */
11912 free_frame_faces (f
);
11913 XFlush (FRAME_X_DISPLAY (f
));
11916 if (f
->output_data
.x
->saved_menu_event
)
11917 xfree (f
->output_data
.x
->saved_menu_event
);
11919 xfree (f
->output_data
.x
);
11920 f
->output_data
.x
= 0;
11921 if (f
== dpyinfo
->x_focus_frame
)
11922 dpyinfo
->x_focus_frame
= 0;
11923 if (f
== dpyinfo
->x_focus_event_frame
)
11924 dpyinfo
->x_focus_event_frame
= 0;
11925 if (f
== dpyinfo
->x_highlight_frame
)
11926 dpyinfo
->x_highlight_frame
= 0;
11928 dpyinfo
->reference_count
--;
11930 if (f
== dpyinfo
->mouse_face_mouse_frame
)
11932 dpyinfo
->mouse_face_beg_row
11933 = dpyinfo
->mouse_face_beg_col
= -1;
11934 dpyinfo
->mouse_face_end_row
11935 = dpyinfo
->mouse_face_end_col
= -1;
11936 dpyinfo
->mouse_face_window
= Qnil
;
11937 dpyinfo
->mouse_face_deferred_gc
= 0;
11938 dpyinfo
->mouse_face_mouse_frame
= 0;
11944 /* Setting window manager hints. */
11946 /* Set the normal size hints for the window manager, for frame F.
11947 FLAGS is the flags word to use--or 0 meaning preserve the flags
11948 that the window now has.
11949 If USER_POSITION is nonzero, we set the USPosition
11950 flag (this is useful when FLAGS is 0). */
11953 x_wm_set_size_hint (f
, flags
, user_position
)
11958 XSizeHints size_hints
;
11960 #ifdef USE_X_TOOLKIT
11963 Dimension widget_width
, widget_height
;
11964 Window window
= XtWindow (f
->output_data
.x
->widget
);
11965 #else /* not USE_X_TOOLKIT */
11966 Window window
= FRAME_X_WINDOW (f
);
11967 #endif /* not USE_X_TOOLKIT */
11969 /* Setting PMaxSize caused various problems. */
11970 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
11972 size_hints
.x
= f
->output_data
.x
->left_pos
;
11973 size_hints
.y
= f
->output_data
.x
->top_pos
;
11975 #ifdef USE_X_TOOLKIT
11976 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
11977 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
11978 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
11979 size_hints
.height
= widget_height
;
11980 size_hints
.width
= widget_width
;
11981 #else /* not USE_X_TOOLKIT */
11982 size_hints
.height
= PIXEL_HEIGHT (f
);
11983 size_hints
.width
= PIXEL_WIDTH (f
);
11984 #endif /* not USE_X_TOOLKIT */
11986 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
11987 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
11988 size_hints
.max_width
11989 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
11990 size_hints
.max_height
11991 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
11993 /* Calculate the base and minimum sizes.
11995 (When we use the X toolkit, we don't do it here.
11996 Instead we copy the values that the widgets are using, below.) */
11997 #ifndef USE_X_TOOLKIT
11999 int base_width
, base_height
;
12000 int min_rows
= 0, min_cols
= 0;
12002 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
12003 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
12005 check_frame_size (f
, &min_rows
, &min_cols
);
12007 /* The window manager uses the base width hints to calculate the
12008 current number of rows and columns in the frame while
12009 resizing; min_width and min_height aren't useful for this
12010 purpose, since they might not give the dimensions for a
12011 zero-row, zero-column frame.
12013 We use the base_width and base_height members if we have
12014 them; otherwise, we set the min_width and min_height members
12015 to the size for a zero x zero frame. */
12018 size_hints
.flags
|= PBaseSize
;
12019 size_hints
.base_width
= base_width
;
12020 size_hints
.base_height
= base_height
;
12021 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
12022 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
12024 size_hints
.min_width
= base_width
;
12025 size_hints
.min_height
= base_height
;
12029 /* If we don't need the old flags, we don't need the old hint at all. */
12032 size_hints
.flags
|= flags
;
12035 #endif /* not USE_X_TOOLKIT */
12038 XSizeHints hints
; /* Sometimes I hate X Windows... */
12039 long supplied_return
;
12043 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
12046 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
12049 #ifdef USE_X_TOOLKIT
12050 size_hints
.base_height
= hints
.base_height
;
12051 size_hints
.base_width
= hints
.base_width
;
12052 size_hints
.min_height
= hints
.min_height
;
12053 size_hints
.min_width
= hints
.min_width
;
12057 size_hints
.flags
|= flags
;
12062 if (hints
.flags
& PSize
)
12063 size_hints
.flags
|= PSize
;
12064 if (hints
.flags
& PPosition
)
12065 size_hints
.flags
|= PPosition
;
12066 if (hints
.flags
& USPosition
)
12067 size_hints
.flags
|= USPosition
;
12068 if (hints
.flags
& USSize
)
12069 size_hints
.flags
|= USSize
;
12073 #ifndef USE_X_TOOLKIT
12078 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
12079 size_hints
.flags
|= PWinGravity
;
12083 size_hints
.flags
&= ~ PPosition
;
12084 size_hints
.flags
|= USPosition
;
12086 #endif /* PWinGravity */
12089 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
12091 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
12095 /* Used for IconicState or NormalState */
12098 x_wm_set_window_state (f
, state
)
12102 #ifdef USE_X_TOOLKIT
12105 XtSetArg (al
[0], XtNinitialState
, state
);
12106 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
12107 #else /* not USE_X_TOOLKIT */
12108 Window window
= FRAME_X_WINDOW (f
);
12110 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
12111 f
->output_data
.x
->wm_hints
.initial_state
= state
;
12113 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12114 #endif /* not USE_X_TOOLKIT */
12118 x_wm_set_icon_pixmap (f
, pixmap_id
)
12122 Pixmap icon_pixmap
;
12124 #ifndef USE_X_TOOLKIT
12125 Window window
= FRAME_X_WINDOW (f
);
12130 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
12131 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
12135 /* It seems there is no way to turn off use of an icon pixmap.
12136 The following line does it, only if no icon has yet been created,
12137 for some window managers. But with mwm it crashes.
12138 Some people say it should clear the IconPixmapHint bit in this case,
12139 but that doesn't work, and the X consortium said it isn't the
12140 right thing at all. Since there is no way to win,
12141 best to explicitly give up. */
12143 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
12149 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
12153 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
12154 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
12157 #else /* not USE_X_TOOLKIT */
12159 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
12160 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12162 #endif /* not USE_X_TOOLKIT */
12166 x_wm_set_icon_position (f
, icon_x
, icon_y
)
12168 int icon_x
, icon_y
;
12170 #ifdef USE_X_TOOLKIT
12171 Window window
= XtWindow (f
->output_data
.x
->widget
);
12173 Window window
= FRAME_X_WINDOW (f
);
12176 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
12177 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
12178 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
12180 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12184 /***********************************************************************
12186 ***********************************************************************/
12188 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
12191 x_get_font_info (f
, font_idx
)
12195 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
12199 /* Return a list of names of available fonts matching PATTERN on frame
12200 F. If SIZE is not 0, it is the size (maximum bound width) of fonts
12201 to be listed. Frame F NULL means we have not yet created any
12202 frame on X, and consult the first display in x_display_list.
12203 MAXNAMES sets a limit on how many fonts to match. */
12206 x_list_fonts (f
, pattern
, size
, maxnames
)
12208 Lisp_Object pattern
;
12212 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
12213 Lisp_Object tem
, second_best
;
12214 Display
*dpy
= f
!= NULL
? FRAME_X_DISPLAY (f
) : x_display_list
->display
;
12215 int try_XLoadQueryFont
= 0;
12218 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
12219 if (NILP (patterns
))
12220 patterns
= Fcons (pattern
, Qnil
);
12222 if (maxnames
== 1 && !size
)
12223 /* We can return any single font matching PATTERN. */
12224 try_XLoadQueryFont
= 1;
12226 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
12231 pattern
= XCAR (patterns
);
12232 /* See if we cached the result for this particular query.
12233 The cache is an alist of the form:
12234 (((PATTERN . MAXNAMES) (FONTNAME . WIDTH) ...) ...)
12236 if (f
&& (tem
= XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
),
12237 key
= Fcons (pattern
, make_number (maxnames
)),
12238 !NILP (list
= Fassoc (key
, tem
))))
12240 list
= Fcdr_safe (list
);
12241 /* We have a cashed list. Don't have to get the list again. */
12245 /* At first, put PATTERN in the cache. */
12248 count
= x_catch_errors (dpy
);
12250 if (try_XLoadQueryFont
)
12253 unsigned long value
;
12255 font
= XLoadQueryFont (dpy
, XSTRING (pattern
)->data
);
12256 if (x_had_errors_p (dpy
))
12258 /* This error is perhaps due to insufficient memory on X
12259 server. Let's just ignore it. */
12261 x_clear_errors (dpy
);
12265 && XGetFontProperty (font
, XA_FONT
, &value
))
12267 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
12268 int len
= strlen (name
);
12271 /* If DXPC (a Differential X Protocol Compressor)
12272 Ver.3.7 is running, XGetAtomName will return null
12273 string. We must avoid such a name. */
12275 try_XLoadQueryFont
= 0;
12279 names
= (char **) alloca (sizeof (char *));
12280 /* Some systems only allow alloca assigned to a
12282 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
12283 bcopy (name
, names
[0], len
+ 1);
12288 try_XLoadQueryFont
= 0;
12291 XFreeFont (dpy
, font
);
12294 if (!try_XLoadQueryFont
)
12296 /* We try at least 10 fonts because XListFonts will return
12297 auto-scaled fonts at the head. */
12298 names
= XListFonts (dpy
, XSTRING (pattern
)->data
, max (maxnames
, 10),
12300 if (x_had_errors_p (dpy
))
12302 /* This error is perhaps due to insufficient memory on X
12303 server. Let's just ignore it. */
12305 x_clear_errors (dpy
);
12309 x_uncatch_errors (dpy
, count
);
12316 /* Make a list of all the fonts we got back.
12317 Store that in the font cache for the display. */
12318 for (i
= 0; i
< num_fonts
; i
++)
12321 char *p
= names
[i
];
12322 int average_width
= -1, dashes
= 0;
12324 /* Count the number of dashes in NAMES[I]. If there are
12325 14 dashes, and the field value following 12th dash
12326 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
12327 is usually too ugly to be used for editing. Let's
12333 if (dashes
== 7) /* PIXEL_SIZE field */
12335 else if (dashes
== 12) /* AVERAGE_WIDTH field */
12336 average_width
= atoi (p
);
12338 if (dashes
< 14 || average_width
!= 0)
12340 tem
= build_string (names
[i
]);
12341 if (NILP (Fassoc (tem
, list
)))
12343 if (STRINGP (Vx_pixel_size_width_font_regexp
)
12344 && ((fast_c_string_match_ignore_case
12345 (Vx_pixel_size_width_font_regexp
, names
[i
]))
12347 /* We can set the value of PIXEL_SIZE to the
12348 width of this font. */
12349 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
12351 /* For the moment, width is not known. */
12352 list
= Fcons (Fcons (tem
, Qnil
), list
);
12356 if (!try_XLoadQueryFont
)
12357 XFreeFontNames (names
);
12360 /* Now store the result in the cache. */
12362 XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
)
12363 = Fcons (Fcons (key
, list
),
12364 XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
));
12367 if (NILP (list
)) continue; /* Try the remaining alternatives. */
12369 newlist
= second_best
= Qnil
;
12370 /* Make a list of the fonts that have the right width. */
12371 for (; CONSP (list
); list
= XCDR (list
))
12377 if (!CONSP (tem
) || NILP (XCAR (tem
)))
12381 newlist
= Fcons (XCAR (tem
), newlist
);
12385 if (!INTEGERP (XCDR (tem
)))
12387 /* Since we have not yet known the size of this font, we
12388 must try slow function call XLoadQueryFont. */
12389 XFontStruct
*thisinfo
;
12392 count
= x_catch_errors (dpy
);
12393 thisinfo
= XLoadQueryFont (dpy
,
12394 XSTRING (XCAR (tem
))->data
);
12395 if (x_had_errors_p (dpy
))
12397 /* This error is perhaps due to insufficient memory on X
12398 server. Let's just ignore it. */
12400 x_clear_errors (dpy
);
12402 x_uncatch_errors (dpy
, count
);
12408 = (thisinfo
->min_bounds
.width
== 0
12410 : make_number (thisinfo
->max_bounds
.width
));
12411 XFreeFont (dpy
, thisinfo
);
12414 /* For unknown reason, the previous call of XListFont had
12415 returned a font which can't be opened. Record the size
12416 as 0 not to try to open it again. */
12417 XCDR (tem
) = make_number (0);
12420 found_size
= XINT (XCDR (tem
));
12421 if (found_size
== size
)
12422 newlist
= Fcons (XCAR (tem
), newlist
);
12423 else if (found_size
> 0)
12425 if (NILP (second_best
))
12427 else if (found_size
< size
)
12429 if (XINT (XCDR (second_best
)) > size
12430 || XINT (XCDR (second_best
)) < found_size
)
12435 if (XINT (XCDR (second_best
)) > size
12436 && XINT (XCDR (second_best
)) > found_size
)
12441 if (!NILP (newlist
))
12443 else if (!NILP (second_best
))
12445 newlist
= Fcons (XCAR (second_best
), Qnil
);
12456 /* Check that FONT is valid on frame F. It is if it can be found in F's
12460 x_check_font (f
, font
)
12465 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12467 xassert (font
!= NULL
);
12469 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12470 if (dpyinfo
->font_table
[i
].name
12471 && font
== dpyinfo
->font_table
[i
].font
)
12474 xassert (i
< dpyinfo
->n_fonts
);
12477 #endif /* GLYPH_DEBUG != 0 */
12479 /* Set *W to the minimum width, *H to the minimum font height of FONT.
12480 Note: There are (broken) X fonts out there with invalid XFontStruct
12481 min_bounds contents. For example, handa@etl.go.jp reports that
12482 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
12483 have font->min_bounds.width == 0. */
12486 x_font_min_bounds (font
, w
, h
)
12490 *h
= FONT_HEIGHT (font
);
12491 *w
= font
->min_bounds
.width
;
12493 /* Try to handle the case where FONT->min_bounds has invalid
12494 contents. Since the only font known to have invalid min_bounds
12495 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
12497 *w
= font
->max_bounds
.width
;
12501 /* Compute the smallest character width and smallest font height over
12502 all fonts available on frame F. Set the members smallest_char_width
12503 and smallest_font_height in F's x_display_info structure to
12504 the values computed. Value is non-zero if smallest_font_height or
12505 smallest_char_width become smaller than they were before. */
12508 x_compute_min_glyph_bounds (f
)
12512 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12514 int old_width
= dpyinfo
->smallest_char_width
;
12515 int old_height
= dpyinfo
->smallest_font_height
;
12517 dpyinfo
->smallest_font_height
= 100000;
12518 dpyinfo
->smallest_char_width
= 100000;
12520 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
12521 if (dpyinfo
->font_table
[i
].name
)
12523 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
12526 font
= (XFontStruct
*) fontp
->font
;
12527 xassert (font
!= (XFontStruct
*) ~0);
12528 x_font_min_bounds (font
, &w
, &h
);
12530 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
12531 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
12534 xassert (dpyinfo
->smallest_char_width
> 0
12535 && dpyinfo
->smallest_font_height
> 0);
12537 return (dpyinfo
->n_fonts
== 1
12538 || dpyinfo
->smallest_char_width
< old_width
12539 || dpyinfo
->smallest_font_height
< old_height
);
12543 /* Load font named FONTNAME of the size SIZE for frame F, and return a
12544 pointer to the structure font_info while allocating it dynamically.
12545 If SIZE is 0, load any size of font.
12546 If loading is failed, return NULL. */
12549 x_load_font (f
, fontname
, size
)
12551 register char *fontname
;
12554 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12555 Lisp_Object font_names
;
12558 /* Get a list of all the fonts that match this name. Once we
12559 have a list of matching fonts, we compare them against the fonts
12560 we already have by comparing names. */
12561 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
12563 if (!NILP (font_names
))
12568 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12569 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
12570 if (dpyinfo
->font_table
[i
].name
12571 && (!strcmp (dpyinfo
->font_table
[i
].name
,
12572 XSTRING (XCAR (tail
))->data
)
12573 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
12574 XSTRING (XCAR (tail
))->data
)))
12575 return (dpyinfo
->font_table
+ i
);
12578 /* Load the font and add it to the table. */
12582 struct font_info
*fontp
;
12583 unsigned long value
;
12586 /* If we have found fonts by x_list_font, load one of them. If
12587 not, we still try to load a font by the name given as FONTNAME
12588 because XListFonts (called in x_list_font) of some X server has
12589 a bug of not finding a font even if the font surely exists and
12590 is loadable by XLoadQueryFont. */
12591 if (size
> 0 && !NILP (font_names
))
12592 fontname
= (char *) XSTRING (XCAR (font_names
))->data
;
12595 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
12596 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
12597 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
12599 /* This error is perhaps due to insufficient memory on X
12600 server. Let's just ignore it. */
12602 x_clear_errors (FRAME_X_DISPLAY (f
));
12604 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
12609 /* Find a free slot in the font table. */
12610 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
12611 if (dpyinfo
->font_table
[i
].name
== NULL
)
12614 /* If no free slot found, maybe enlarge the font table. */
12615 if (i
== dpyinfo
->n_fonts
12616 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
12619 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
12620 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
12621 dpyinfo
->font_table
12622 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
12625 fontp
= dpyinfo
->font_table
+ i
;
12626 if (i
== dpyinfo
->n_fonts
)
12627 ++dpyinfo
->n_fonts
;
12629 /* Now fill in the slots of *FONTP. */
12631 fontp
->font
= font
;
12632 fontp
->font_idx
= i
;
12633 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
12634 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
12636 /* Try to get the full name of FONT. Put it in FULL_NAME. */
12638 if (XGetFontProperty (font
, XA_FONT
, &value
))
12640 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
12644 /* Count the number of dashes in the "full name".
12645 If it is too few, this isn't really the font's full name,
12647 In X11R4, the fonts did not come with their canonical names
12658 full_name
= (char *) xmalloc (p
- name
+ 1);
12659 bcopy (name
, full_name
, p
- name
+ 1);
12665 if (full_name
!= 0)
12666 fontp
->full_name
= full_name
;
12668 fontp
->full_name
= fontp
->name
;
12670 fontp
->size
= font
->max_bounds
.width
;
12671 fontp
->height
= FONT_HEIGHT (font
);
12673 /* For some font, ascent and descent in max_bounds field is
12674 larger than the above value. */
12675 int max_height
= font
->max_bounds
.ascent
+ font
->max_bounds
.descent
;
12676 if (max_height
> fontp
->height
)
12677 fontp
->height
= max_height
;
12680 if (NILP (font_names
))
12682 /* We come here because of a bug of XListFonts mentioned at
12683 the head of this block. Let's store this information in
12684 the cache for x_list_fonts. */
12685 Lisp_Object lispy_name
= build_string (fontname
);
12686 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
12688 XCDR (dpyinfo
->name_list_element
)
12689 = Fcons (Fcons (Fcons (lispy_name
, make_number (256)),
12690 Fcons (Fcons (lispy_full_name
,
12691 make_number (fontp
->size
)),
12693 XCDR (dpyinfo
->name_list_element
));
12695 XCDR (dpyinfo
->name_list_element
)
12696 = Fcons (Fcons (Fcons (lispy_full_name
, make_number (256)),
12697 Fcons (Fcons (lispy_full_name
,
12698 make_number (fontp
->size
)),
12700 XCDR (dpyinfo
->name_list_element
));
12703 /* The slot `encoding' specifies how to map a character
12704 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
12705 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
12706 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
12707 2:0xA020..0xFF7F). For the moment, we don't know which charset
12708 uses this font. So, we set information in fontp->encoding[1]
12709 which is never used by any charset. If mapping can't be
12710 decided, set FONT_ENCODING_NOT_DECIDED. */
12712 = (font
->max_byte1
== 0
12714 ? (font
->min_char_or_byte2
< 0x80
12715 ? (font
->max_char_or_byte2
< 0x80
12716 ? 0 /* 0x20..0x7F */
12717 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
12718 : 1) /* 0xA0..0xFF */
12720 : (font
->min_byte1
< 0x80
12721 ? (font
->max_byte1
< 0x80
12722 ? (font
->min_char_or_byte2
< 0x80
12723 ? (font
->max_char_or_byte2
< 0x80
12724 ? 0 /* 0x2020..0x7F7F */
12725 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
12726 : 3) /* 0x20A0..0x7FFF */
12727 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
12728 : (font
->min_char_or_byte2
< 0x80
12729 ? (font
->max_char_or_byte2
< 0x80
12730 ? 2 /* 0xA020..0xFF7F */
12731 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
12732 : 1))); /* 0xA0A0..0xFFFF */
12734 fontp
->baseline_offset
12735 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
12736 ? (long) value
: 0);
12737 fontp
->relative_compose
12738 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
12739 ? (long) value
: 0);
12740 fontp
->default_ascent
12741 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
12742 ? (long) value
: 0);
12744 /* Set global flag fonts_changed_p to non-zero if the font loaded
12745 has a character with a smaller width than any other character
12746 before, or if the font loaded has a smalle>r height than any
12747 other font loaded before. If this happens, it will make a
12748 glyph matrix reallocation necessary. */
12749 fonts_changed_p
= x_compute_min_glyph_bounds (f
);
12756 /* Return a pointer to struct font_info of a font named FONTNAME for
12757 frame F. If no such font is loaded, return NULL. */
12760 x_query_font (f
, fontname
)
12762 register char *fontname
;
12764 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12767 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12768 if (dpyinfo
->font_table
[i
].name
12769 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
12770 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
12771 return (dpyinfo
->font_table
+ i
);
12776 /* Find a CCL program for a font specified by FONTP, and set the member
12777 `encoder' of the structure. */
12780 x_find_ccl_program (fontp
)
12781 struct font_info
*fontp
;
12783 Lisp_Object list
, elt
;
12785 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
12789 && STRINGP (XCAR (elt
))
12790 && (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
12796 struct ccl_program
*ccl
12797 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
12799 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
12802 fontp
->font_encoder
= ccl
;
12808 /***********************************************************************
12810 ***********************************************************************/
12812 #ifdef USE_X_TOOLKIT
12813 static XrmOptionDescRec emacs_options
[] = {
12814 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
12815 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
12817 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
12818 XrmoptionSepArg
, NULL
},
12819 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
12821 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
12822 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
12823 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
12824 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
12825 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
12826 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
12827 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
12829 #endif /* USE_X_TOOLKIT */
12831 static int x_initialized
;
12833 #ifdef MULTI_KBOARD
12834 /* Test whether two display-name strings agree up to the dot that separates
12835 the screen number from the server number. */
12837 same_x_server (name1
, name2
)
12838 char *name1
, *name2
;
12840 int seen_colon
= 0;
12841 unsigned char *system_name
= XSTRING (Vsystem_name
)->data
;
12842 int system_name_length
= strlen (system_name
);
12843 int length_until_period
= 0;
12845 while (system_name
[length_until_period
] != 0
12846 && system_name
[length_until_period
] != '.')
12847 length_until_period
++;
12849 /* Treat `unix' like an empty host name. */
12850 if (! strncmp (name1
, "unix:", 5))
12852 if (! strncmp (name2
, "unix:", 5))
12854 /* Treat this host's name like an empty host name. */
12855 if (! strncmp (name1
, system_name
, system_name_length
)
12856 && name1
[system_name_length
] == ':')
12857 name1
+= system_name_length
;
12858 if (! strncmp (name2
, system_name
, system_name_length
)
12859 && name2
[system_name_length
] == ':')
12860 name2
+= system_name_length
;
12861 /* Treat this host's domainless name like an empty host name. */
12862 if (! strncmp (name1
, system_name
, length_until_period
)
12863 && name1
[length_until_period
] == ':')
12864 name1
+= length_until_period
;
12865 if (! strncmp (name2
, system_name
, length_until_period
)
12866 && name2
[length_until_period
] == ':')
12867 name2
+= length_until_period
;
12869 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
12873 if (seen_colon
&& *name1
== '.')
12877 && (*name1
== '.' || *name1
== '\0')
12878 && (*name2
== '.' || *name2
== '\0'));
12882 struct x_display_info
*
12883 x_term_init (display_name
, xrm_option
, resource_name
)
12884 Lisp_Object display_name
;
12886 char *resource_name
;
12890 struct x_display_info
*dpyinfo
;
12895 if (!x_initialized
)
12901 #ifdef USE_X_TOOLKIT
12902 /* weiner@footloose.sps.mot.com reports that this causes
12904 X protocol error: BadAtom (invalid Atom parameter)
12905 on protocol request 18skiloaf.
12906 So let's not use it until R6. */
12907 #ifdef HAVE_X11XTR6
12908 XtSetLanguageProc (NULL
, NULL
, NULL
);
12919 argv
[argc
++] = "-xrm";
12920 argv
[argc
++] = xrm_option
;
12922 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
12923 resource_name
, EMACS_CLASS
,
12924 emacs_options
, XtNumber (emacs_options
),
12927 #ifdef HAVE_X11XTR6
12928 /* I think this is to compensate for XtSetLanguageProc. */
12933 #else /* not USE_X_TOOLKIT */
12935 XSetLocaleModifiers ("");
12937 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
12938 #endif /* not USE_X_TOOLKIT */
12940 /* Detect failure. */
12947 /* We have definitely succeeded. Record the new connection. */
12949 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
12951 #ifdef MULTI_KBOARD
12953 struct x_display_info
*share
;
12956 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
12957 share
= share
->next
, tail
= XCDR (tail
))
12958 if (same_x_server (XSTRING (XCAR (XCAR (tail
)))->data
,
12959 XSTRING (display_name
)->data
))
12962 dpyinfo
->kboard
= share
->kboard
;
12965 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
12966 init_kboard (dpyinfo
->kboard
);
12967 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
12969 char *vendor
= ServerVendor (dpy
);
12971 dpyinfo
->kboard
->Vsystem_key_alist
12972 = call1 (Qvendor_specific_keysyms
,
12973 build_string (vendor
? vendor
: ""));
12977 dpyinfo
->kboard
->next_kboard
= all_kboards
;
12978 all_kboards
= dpyinfo
->kboard
;
12979 /* Don't let the initial kboard remain current longer than necessary.
12980 That would cause problems if a file loaded on startup tries to
12981 prompt in the mini-buffer. */
12982 if (current_kboard
== initial_kboard
)
12983 current_kboard
= dpyinfo
->kboard
;
12985 dpyinfo
->kboard
->reference_count
++;
12989 /* Put this display on the chain. */
12990 dpyinfo
->next
= x_display_list
;
12991 x_display_list
= dpyinfo
;
12993 /* Put it on x_display_name_list as well, to keep them parallel. */
12994 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
12995 x_display_name_list
);
12996 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
12998 dpyinfo
->display
= dpy
;
13001 XSetAfterFunction (x_current_display
, x_trace_wire
);
13005 = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name
))
13006 + STRING_BYTES (XSTRING (Vsystem_name
))
13008 sprintf (dpyinfo
->x_id_name
, "%s@%s",
13009 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
13011 /* Figure out which modifier bits mean what. */
13012 x_find_modifier_meanings (dpyinfo
);
13014 /* Get the scroll bar cursor. */
13015 dpyinfo
->vertical_scroll_bar_cursor
13016 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
13018 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
13019 resource_name
, EMACS_CLASS
);
13020 #ifdef HAVE_XRMSETDATABASE
13021 XrmSetDatabase (dpyinfo
->display
, xrdb
);
13023 dpyinfo
->display
->db
= xrdb
;
13025 /* Put the rdb where we can find it in a way that works on
13027 dpyinfo
->xrdb
= xrdb
;
13029 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
13030 DefaultScreen (dpyinfo
->display
));
13031 select_visual (dpyinfo
);
13032 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
13033 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
13034 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
13035 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
13036 dpyinfo
->grabbed
= 0;
13037 dpyinfo
->reference_count
= 0;
13038 dpyinfo
->icon_bitmap_id
= -1;
13039 dpyinfo
->font_table
= NULL
;
13040 dpyinfo
->n_fonts
= 0;
13041 dpyinfo
->font_table_size
= 0;
13042 dpyinfo
->bitmaps
= 0;
13043 dpyinfo
->bitmaps_size
= 0;
13044 dpyinfo
->bitmaps_last
= 0;
13045 dpyinfo
->scratch_cursor_gc
= 0;
13046 dpyinfo
->mouse_face_mouse_frame
= 0;
13047 dpyinfo
->mouse_face_deferred_gc
= 0;
13048 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
13049 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
13050 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
13051 dpyinfo
->mouse_face_window
= Qnil
;
13052 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
13053 dpyinfo
->mouse_face_defer
= 0;
13054 dpyinfo
->x_focus_frame
= 0;
13055 dpyinfo
->x_focus_event_frame
= 0;
13056 dpyinfo
->x_highlight_frame
= 0;
13057 dpyinfo
->image_cache
= make_image_cache ();
13059 /* See if a private colormap is requested. */
13060 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
13062 if (dpyinfo
->visual
->class == PseudoColor
)
13065 value
= display_x_get_resource (dpyinfo
,
13066 build_string ("privateColormap"),
13067 build_string ("PrivateColormap"),
13069 if (STRINGP (value
)
13070 && (!strcmp (XSTRING (value
)->data
, "true")
13071 || !strcmp (XSTRING (value
)->data
, "on")))
13072 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
13076 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
13077 dpyinfo
->visual
, AllocNone
);
13080 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
13081 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
13082 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
13083 dpyinfo
->resy
= pixels
* 25.4 / mm
;
13084 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
13085 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
13086 dpyinfo
->resx
= pixels
* 25.4 / mm
;
13089 dpyinfo
->Xatom_wm_protocols
13090 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
13091 dpyinfo
->Xatom_wm_take_focus
13092 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
13093 dpyinfo
->Xatom_wm_save_yourself
13094 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
13095 dpyinfo
->Xatom_wm_delete_window
13096 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
13097 dpyinfo
->Xatom_wm_change_state
13098 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
13099 dpyinfo
->Xatom_wm_configure_denied
13100 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
13101 dpyinfo
->Xatom_wm_window_moved
13102 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
13103 dpyinfo
->Xatom_editres
13104 = XInternAtom (dpyinfo
->display
, "Editres", False
);
13105 dpyinfo
->Xatom_CLIPBOARD
13106 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
13107 dpyinfo
->Xatom_TIMESTAMP
13108 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
13109 dpyinfo
->Xatom_TEXT
13110 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
13111 dpyinfo
->Xatom_COMPOUND_TEXT
13112 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
13113 dpyinfo
->Xatom_DELETE
13114 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
13115 dpyinfo
->Xatom_MULTIPLE
13116 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
13117 dpyinfo
->Xatom_INCR
13118 = XInternAtom (dpyinfo
->display
, "INCR", False
);
13119 dpyinfo
->Xatom_EMACS_TMP
13120 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
13121 dpyinfo
->Xatom_TARGETS
13122 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
13123 dpyinfo
->Xatom_NULL
13124 = XInternAtom (dpyinfo
->display
, "NULL", False
);
13125 dpyinfo
->Xatom_ATOM_PAIR
13126 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
13127 /* For properties of font. */
13128 dpyinfo
->Xatom_PIXEL_SIZE
13129 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
13130 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
13131 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
13132 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
13133 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
13134 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
13135 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
13137 /* Ghostscript support. */
13138 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
13139 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
13141 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
13144 dpyinfo
->cut_buffers_initialized
= 0;
13146 connection
= ConnectionNumber (dpyinfo
->display
);
13147 dpyinfo
->connection
= connection
;
13152 null_bits
[0] = 0x00;
13154 dpyinfo
->null_pixel
13155 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
13156 null_bits
, 1, 1, (long) 0, (long) 0,
13161 extern int gray_bitmap_width
, gray_bitmap_height
;
13162 extern unsigned char *gray_bitmap_bits
;
13164 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
13166 gray_bitmap_width
, gray_bitmap_height
,
13167 (unsigned long) 1, (unsigned long) 0, 1);
13171 xim_initialize (dpyinfo
, resource_name
);
13174 #ifdef subprocesses
13175 /* This is only needed for distinguishing keyboard and process input. */
13176 if (connection
!= 0)
13177 add_keyboard_wait_descriptor (connection
);
13180 #ifndef F_SETOWN_BUG
13182 #ifdef F_SETOWN_SOCK_NEG
13183 /* stdin is a socket here */
13184 fcntl (connection
, F_SETOWN
, -getpid ());
13185 #else /* ! defined (F_SETOWN_SOCK_NEG) */
13186 fcntl (connection
, F_SETOWN
, getpid ());
13187 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
13188 #endif /* ! defined (F_SETOWN) */
13189 #endif /* F_SETOWN_BUG */
13192 if (interrupt_input
)
13193 init_sigio (connection
);
13194 #endif /* ! defined (SIGIO) */
13197 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
13198 /* Make sure that we have a valid font for dialog boxes
13199 so that Xt does not crash. */
13201 Display
*dpy
= dpyinfo
->display
;
13202 XrmValue d
, fr
, to
;
13206 d
.addr
= (XPointer
)&dpy
;
13207 d
.size
= sizeof (Display
*);
13208 fr
.addr
= XtDefaultFont
;
13209 fr
.size
= sizeof (XtDefaultFont
);
13210 to
.size
= sizeof (Font
*);
13211 to
.addr
= (XPointer
)&font
;
13212 count
= x_catch_errors (dpy
);
13213 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
13215 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
13216 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
13217 x_uncatch_errors (dpy
, count
);
13222 /* See if we should run in synchronous mode. This is useful
13223 for debugging X code. */
13226 value
= display_x_get_resource (dpyinfo
,
13227 build_string ("synchronous"),
13228 build_string ("Synchronous"),
13230 if (STRINGP (value
)
13231 && (!strcmp (XSTRING (value
)->data
, "true")
13232 || !strcmp (XSTRING (value
)->data
, "on")))
13233 XSynchronize (dpyinfo
->display
, True
);
13241 /* Get rid of display DPYINFO, assuming all frames are already gone,
13242 and without sending any more commands to the X server. */
13245 x_delete_display (dpyinfo
)
13246 struct x_display_info
*dpyinfo
;
13248 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
13250 /* Discard this display from x_display_name_list and x_display_list.
13251 We can't use Fdelq because that can quit. */
13252 if (! NILP (x_display_name_list
)
13253 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
13254 x_display_name_list
= XCDR (x_display_name_list
);
13259 tail
= x_display_name_list
;
13260 while (CONSP (tail
) && CONSP (XCDR (tail
)))
13262 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
13264 XCDR (tail
) = XCDR (XCDR (tail
));
13267 tail
= XCDR (tail
);
13271 if (next_noop_dpyinfo
== dpyinfo
)
13272 next_noop_dpyinfo
= dpyinfo
->next
;
13274 if (x_display_list
== dpyinfo
)
13275 x_display_list
= dpyinfo
->next
;
13278 struct x_display_info
*tail
;
13280 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
13281 if (tail
->next
== dpyinfo
)
13282 tail
->next
= tail
->next
->next
;
13285 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
13286 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
13287 XrmDestroyDatabase (dpyinfo
->xrdb
);
13290 #ifdef MULTI_KBOARD
13291 if (--dpyinfo
->kboard
->reference_count
== 0)
13292 delete_kboard (dpyinfo
->kboard
);
13296 xim_close_dpy (dpyinfo
);
13299 xfree (dpyinfo
->font_table
);
13300 xfree (dpyinfo
->x_id_name
);
13304 /* Set up use of X before we make the first connection. */
13306 static struct redisplay_interface x_redisplay_interface
=
13311 x_clear_end_of_line
,
13313 x_after_update_window_line
,
13314 x_update_window_begin
,
13315 x_update_window_end
,
13318 x_get_glyph_overhangs
,
13319 x_fix_overlapping_area
13325 rif
= &x_redisplay_interface
;
13327 clear_frame_hook
= x_clear_frame
;
13328 ins_del_lines_hook
= x_ins_del_lines
;
13329 change_line_highlight_hook
= x_change_line_highlight
;
13330 delete_glyphs_hook
= x_delete_glyphs
;
13331 ring_bell_hook
= XTring_bell
;
13332 reset_terminal_modes_hook
= XTreset_terminal_modes
;
13333 set_terminal_modes_hook
= XTset_terminal_modes
;
13334 update_begin_hook
= x_update_begin
;
13335 update_end_hook
= x_update_end
;
13336 set_terminal_window_hook
= XTset_terminal_window
;
13337 read_socket_hook
= XTread_socket
;
13338 frame_up_to_date_hook
= XTframe_up_to_date
;
13339 reassert_line_highlight_hook
= XTreassert_line_highlight
;
13340 mouse_position_hook
= XTmouse_position
;
13341 frame_rehighlight_hook
= XTframe_rehighlight
;
13342 frame_raise_lower_hook
= XTframe_raise_lower
;
13343 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
13344 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
13345 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
13346 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
13347 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
13349 scroll_region_ok
= 1; /* we'll scroll partial frames */
13350 char_ins_del_ok
= 0; /* just as fast to write the line */
13351 line_ins_del_ok
= 1; /* we'll just blt 'em */
13352 fast_clear_end_of_line
= 1; /* X does this well */
13353 memory_below_frame
= 0; /* we don't remember what scrolls
13358 last_tool_bar_item
= -1;
13359 any_help_event_p
= 0;
13361 /* Try to use interrupt input; if we can't, then start polling. */
13362 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
13364 #ifdef USE_X_TOOLKIT
13365 XtToolkitInitialize ();
13366 Xt_app_con
= XtCreateApplicationContext ();
13367 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
13369 /* Install an asynchronous timer that processes Xt timeout events
13370 every 0.1s. This is necessary because some widget sets use
13371 timeouts internally, for example the LessTif menu bar, or the
13372 Xaw3d scroll bar. When Xt timouts aren't processed, these
13373 widgets don't behave normally. */
13375 EMACS_TIME interval
;
13376 EMACS_SET_SECS_USECS (interval
, 0, 100000);
13377 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
13381 #if USE_TOOLKIT_SCROLL_BARS
13382 xaw3d_arrow_scroll
= False
;
13383 xaw3d_pick_top
= True
;
13386 /* Note that there is no real way portable across R3/R4 to get the
13387 original error handler. */
13388 XSetErrorHandler (x_error_handler
);
13389 XSetIOErrorHandler (x_io_error_quitter
);
13391 /* Disable Window Change signals; they are handled by X events. */
13393 signal (SIGWINCH
, SIG_DFL
);
13394 #endif /* ! defined (SIGWINCH) */
13396 signal (SIGPIPE
, x_connection_signal
);
13403 staticpro (&x_error_message_string
);
13404 x_error_message_string
= Qnil
;
13406 staticpro (&x_display_name_list
);
13407 x_display_name_list
= Qnil
;
13409 staticpro (&last_mouse_scroll_bar
);
13410 last_mouse_scroll_bar
= Qnil
;
13412 staticpro (&Qvendor_specific_keysyms
);
13413 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
13415 staticpro (&last_mouse_press_frame
);
13416 last_mouse_press_frame
= Qnil
;
13418 staticpro (&help_echo
);
13420 staticpro (&previous_help_echo
);
13421 previous_help_echo
= Qnil
;
13423 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
13424 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
13425 For example, if a block cursor is over a tab, it will be drawn as\n\
13426 wide as that tab on the display.");
13427 x_stretch_cursor_p
= 0;
13429 DEFVAR_BOOL ("x-toolkit-scroll-bars-p", &x_toolkit_scroll_bars_p
,
13430 "If not nil, Emacs uses toolkit scroll bars.");
13431 #if USE_TOOLKIT_SCROLL_BARS
13432 x_toolkit_scroll_bars_p
= 1;
13434 x_toolkit_scroll_bars_p
= 0;
13437 staticpro (&last_mouse_motion_frame
);
13438 last_mouse_motion_frame
= Qnil
;
13441 #endif /* not HAVE_X_WINDOWS */