1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999
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
);
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
;
1826 it
->phys_ascent
= pcm
->ascent
+ boff
;
1827 it
->phys_descent
= pcm
->descent
- boff
;
1828 it
->pixel_width
= pcm
->width
;
1830 /* If this is a space inside a region of text with
1831 `space-width' property, change its width. */
1832 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
1834 it
->pixel_width
*= XFLOATINT (it
->space_width
);
1836 /* If face has a box, add the box thickness to the character
1837 height. If character has a box line to the left and/or
1838 right, add the box line width to the character's width. */
1839 if (face
->box
!= FACE_NO_BOX
)
1841 int thick
= face
->box_line_width
;
1843 it
->ascent
+= thick
;
1844 it
->descent
+= thick
;
1846 if (it
->start_of_box_run_p
)
1847 it
->pixel_width
+= thick
;
1848 if (it
->end_of_box_run_p
)
1849 it
->pixel_width
+= thick
;
1852 /* If face has an overline, add the height of the overline
1853 (1 pixel) and a 1 pixel margin to the character height. */
1854 if (face
->overline_p
)
1857 take_vertical_position_into_account (it
);
1859 /* If we have to actually produce glyphs, do it. */
1864 /* Translate a space with a `space-width' property
1865 into a stretch glyph. */
1866 double ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
1867 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1868 it
->ascent
+ it
->descent
, ascent
);
1871 x_append_glyph (it
);
1873 /* If characters with lbearing or rbearing are displayed
1874 in this line, record that fact in a flag of the
1875 glyph row. This is used to optimize X output code. */
1876 if (pcm
->lbearing
< 0
1877 || pcm
->rbearing
> pcm
->width
)
1878 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1881 else if (it
->char_to_display
== '\n')
1883 /* A newline has no width but we need the height of the line. */
1884 it
->pixel_width
= 0;
1886 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1887 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1889 if (face
->box
!= FACE_NO_BOX
)
1891 int thick
= face
->box_line_width
;
1892 it
->ascent
+= thick
;
1893 it
->descent
+= thick
;
1896 else if (it
->char_to_display
== '\t')
1898 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
1899 int x
= (it
->current_x
1901 + it
->continuation_lines_width
);
1902 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
1904 it
->pixel_width
= next_tab_x
- x
;
1906 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
1907 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
1911 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
1912 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
1913 it
->ascent
+ it
->descent
, ascent
);
1918 /* A multi-byte character. Assume that the display width of the
1919 character is the width of the character multiplied by the
1920 width of the font. */
1922 /* If we found a font, this font should give us the right
1923 metrics. If we didn't find a font, use the frame's
1924 default font and calculate the width of the character
1925 from the charset width; this is what old redisplay code
1927 pcm
= x_per_char_metric (font
, &char2b
);
1928 if (font_not_found_p
|| !pcm
)
1930 int charset
= CHAR_CHARSET (it
->char_to_display
);
1932 it
->glyph_not_available_p
= 1;
1933 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
1934 * CHARSET_WIDTH (charset
));
1935 it
->phys_ascent
= font
->ascent
+ boff
;
1936 it
->phys_descent
= font
->descent
- boff
;
1940 it
->pixel_width
= pcm
->width
;
1941 it
->phys_ascent
= pcm
->ascent
+ boff
;
1942 it
->phys_descent
= pcm
->descent
- boff
;
1944 && (pcm
->lbearing
< 0
1945 || pcm
->rbearing
> pcm
->width
))
1946 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
1949 it
->ascent
= font
->ascent
+ boff
;
1950 it
->descent
= font
->descent
- boff
;
1951 if (face
->box
!= FACE_NO_BOX
)
1953 int thick
= face
->box_line_width
;
1954 it
->ascent
+= thick
;
1955 it
->descent
+= thick
;
1957 if (it
->start_of_box_run_p
)
1958 it
->pixel_width
+= thick
;
1959 if (it
->end_of_box_run_p
)
1960 it
->pixel_width
+= thick
;
1963 /* If face has an overline, add the height of the overline
1964 (1 pixel) and a 1 pixel margin to the character height. */
1965 if (face
->overline_p
)
1968 take_vertical_position_into_account (it
);
1971 x_append_glyph (it
);
1974 else if (it
->what
== IT_COMPOSITION
)
1976 /* Note: A composition is represented as one glyph in the
1977 glyph matrix. There are no padding glyphs. */
1980 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1982 int font_not_found_p
;
1983 struct font_info
*font_info
;
1984 int boff
; /* baseline offset */
1985 struct composition
*cmp
= composition_table
[it
->cmp_id
];
1987 /* Maybe translate single-byte characters to multibyte. */
1988 it
->char_to_display
= it
->c
;
1989 if (unibyte_display_via_language_environment
1990 && SINGLE_BYTE_CHAR_P (it
->c
)
1993 && !NILP (Vnonascii_translation_table
))))
1995 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
1998 /* Get face and font to use. Encode IT->char_to_display. */
1999 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2000 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2001 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2002 it
->face_id
, &char2b
, it
->multibyte_p
);
2005 /* When no suitable font found, use the default font. */
2006 font_not_found_p
= font
== NULL
;
2007 if (font_not_found_p
)
2009 font
= FRAME_FONT (it
->f
);
2010 boff
= it
->f
->output_data
.x
->baseline_offset
;
2015 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2016 boff
= font_info
->baseline_offset
;
2017 if (font_info
->vertical_centering
)
2018 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2021 /* There are no padding glyphs, so there is only one glyph to
2022 produce for the composition. Important is that pixel_width,
2023 ascent and descent are the values of what is drawn by
2024 draw_glyphs (i.e. the values of the overall glyphs composed). */
2027 /* If we have not yet calculated pixel size data of glyphs of
2028 the composition for the current face font, calculate them
2029 now. Theoretically, we have to check all fonts for the
2030 glyphs, but that requires much time and memory space. So,
2031 here we check only the font of the first glyph. This leads
2032 to incorrect display very rarely, and C-l (recenter) can
2033 correct the display anyway. */
2034 if (cmp
->font
!= (void *) font
)
2036 /* Ascent and descent of the font of the first character of
2037 this composition (adjusted by baseline offset). Ascent
2038 and descent of overall glyphs should not be less than
2039 them respectively. */
2040 int font_ascent
= font
->ascent
+ boff
;
2041 int font_descent
= font
->descent
- boff
;
2042 /* Bounding box of the overall glyphs. */
2043 int leftmost
, rightmost
, lowest
, highest
;
2046 cmp
->font
= (void *) font
;
2048 /* Initialize the bounding box. */
2049 pcm
= x_per_char_metric (font
, &char2b
);
2051 rightmost
= pcm
->width
;
2052 lowest
= - pcm
->descent
+ boff
;
2053 highest
= pcm
->ascent
+ boff
;
2055 && font_info
->default_ascent
2056 && CHAR_TABLE_P (Vuse_default_ascent
)
2057 && !NILP (Faref (Vuse_default_ascent
,
2058 make_number (it
->char_to_display
))))
2059 highest
= font_info
->default_ascent
+ boff
;
2061 /* Draw the first glyph at the normal position. It may be
2062 shifted to right later if some other glyphs are drawn at
2064 cmp
->offsets
[0] = 0;
2065 cmp
->offsets
[1] = boff
;
2067 /* Set cmp->offsets for the remaining glyphs. */
2068 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2070 int left
, right
, btm
, top
;
2071 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2072 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2074 face
= FACE_FROM_ID (it
->f
, face_id
);
2075 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2080 font
= FRAME_FONT (it
->f
);
2081 boff
= it
->f
->output_data
.x
->baseline_offset
;
2087 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2088 boff
= font_info
->baseline_offset
;
2089 if (font_info
->vertical_centering
)
2090 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2093 pcm
= x_per_char_metric (font
, &char2b
);
2095 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2097 /* Relative composition with or without
2099 left
= (leftmost
+ rightmost
- pcm
->width
) / 2;
2100 btm
= - pcm
->descent
+ boff
;
2101 if (font_info
&& font_info
->relative_compose
2102 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2103 || NILP (Faref (Vignore_relative_composition
,
2104 make_number (ch
)))))
2108 >= font_info
->relative_compose
)
2109 /* One extra pixel between two glyphs. */
2111 else if (pcm
->ascent
<= 0)
2112 /* One extra pixel between two glyphs. */
2113 btm
= lowest
- 1 - pcm
->ascent
- pcm
->descent
;
2118 /* A composition rule is specified by an integer
2119 value that encodes global and new reference
2120 points (GREF and NREF). GREF and NREF are
2121 specified by numbers as below:
2129 ---3---4---5--- baseline
2131 6---7---8 -- descent
2133 int rule
= COMPOSITION_RULE (cmp
, i
);
2134 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2136 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2137 grefx
= gref
% 3, nrefx
= nref
% 3;
2138 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2141 + grefx
* (rightmost
- leftmost
) / 2
2142 - nrefx
* pcm
->width
/ 2);
2143 btm
= ((grefy
== 0 ? highest
2145 : grefy
== 2 ? lowest
2146 : (highest
+ lowest
) / 2)
2147 - (nrefy
== 0 ? pcm
->ascent
+ pcm
->descent
2148 : nrefy
== 1 ? pcm
->descent
- boff
2150 : (pcm
->ascent
+ pcm
->descent
) / 2));
2153 cmp
->offsets
[i
* 2] = left
;
2154 cmp
->offsets
[i
* 2 + 1] = btm
+ pcm
->descent
;
2156 /* Update the bounding box of the overall glyphs. */
2157 right
= left
+ pcm
->width
;
2158 top
= btm
+ pcm
->descent
+ pcm
->ascent
;
2159 if (left
< leftmost
)
2161 if (right
> rightmost
)
2169 /* If there are glyphs whose x-offsets are negative,
2170 shift all glyphs to the right and make all x-offsets
2174 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2175 cmp
->offsets
[i
* 2] -= leftmost
;
2176 rightmost
-= leftmost
;
2179 cmp
->pixel_width
= rightmost
;
2180 cmp
->ascent
= highest
;
2181 cmp
->descent
= - lowest
;
2182 if (cmp
->ascent
< font_ascent
)
2183 cmp
->ascent
= font_ascent
;
2184 if (cmp
->descent
< font_descent
)
2185 cmp
->descent
= font_descent
;
2188 it
->pixel_width
= cmp
->pixel_width
;
2189 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2190 it
->descent
= it
->phys_descent
= cmp
->descent
;
2192 if (face
->box
!= FACE_NO_BOX
)
2194 int thick
= face
->box_line_width
;
2195 it
->ascent
+= thick
;
2196 it
->descent
+= thick
;
2198 if (it
->start_of_box_run_p
)
2199 it
->pixel_width
+= thick
;
2200 if (it
->end_of_box_run_p
)
2201 it
->pixel_width
+= thick
;
2204 /* If face has an overline, add the height of the overline
2205 (1 pixel) and a 1 pixel margin to the character height. */
2206 if (face
->overline_p
)
2209 take_vertical_position_into_account (it
);
2212 x_append_composite_glyph (it
);
2214 else if (it
->what
== IT_IMAGE
)
2215 x_produce_image_glyph (it
);
2216 else if (it
->what
== IT_STRETCH
)
2217 x_produce_stretch_glyph (it
);
2219 /* Accumulate dimensions. */
2220 xassert (it
->ascent
>= 0 && it
->descent
> 0);
2221 if (it
->area
== TEXT_AREA
)
2222 it
->current_x
+= it
->pixel_width
;
2224 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2225 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2226 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2227 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2231 /* Estimate the pixel height of the mode or top line on frame F.
2232 FACE_ID specifies what line's height to estimate. */
2235 x_estimate_mode_line_height (f
, face_id
)
2237 enum face_id face_id
;
2241 /* This function is called so early when Emacs starts that the face
2242 cache and mode line face are not yet initialized. */
2243 if (FRAME_FACE_CACHE (f
))
2245 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2247 height
= FONT_HEIGHT (face
->font
) + 2 * face
->box_line_width
;
2254 /***********************************************************************
2256 ***********************************************************************/
2258 /* A sequence of glyphs to be drawn in the same face.
2260 This data structure is not really completely X specific, so it
2261 could possibly, at least partially, be useful for other systems. It
2262 is currently not part of the external redisplay interface because
2263 it's not clear what other systems will need. */
2267 /* X-origin of the string. */
2270 /* Y-origin and y-position of the base line of this string. */
2273 /* The width of the string, not including a face extension. */
2276 /* The width of the string, including a face extension. */
2277 int background_width
;
2279 /* The height of this string. This is the height of the line this
2280 string is drawn in, and can be different from the height of the
2281 font the string is drawn in. */
2284 /* Number of pixels this string overwrites in front of its x-origin.
2285 This number is zero if the string has an lbearing >= 0; it is
2286 -lbearing, if the string has an lbearing < 0. */
2289 /* Number of pixels this string overwrites past its right-most
2290 nominal x-position, i.e. x + width. Zero if the string's
2291 rbearing is <= its nominal width, rbearing - width otherwise. */
2294 /* The frame on which the glyph string is drawn. */
2297 /* The window on which the glyph string is drawn. */
2300 /* X display and window for convenience. */
2304 /* The glyph row for which this string was built. It determines the
2305 y-origin and height of the string. */
2306 struct glyph_row
*row
;
2308 /* The area within row. */
2309 enum glyph_row_area area
;
2311 /* Characters to be drawn, and number of characters. */
2315 /* A face-override for drawing cursors, mouse face and similar. */
2316 enum draw_glyphs_face hl
;
2318 /* Face in which this string is to be drawn. */
2321 /* Font in which this string is to be drawn. */
2324 /* Font info for this string. */
2325 struct font_info
*font_info
;
2327 /* Non-null means this string describes (part of) a composition.
2328 All characters from char2b are drawn composed. */
2329 struct composition
*cmp
;
2331 /* Index of this glyph string's first character in the glyph
2332 definition of CMP. If this is zero, this glyph string describes
2333 the first character of a composition. */
2336 /* 1 means this glyph strings face has to be drawn to the right end
2337 of the window's drawing area. */
2338 unsigned extends_to_end_of_line_p
: 1;
2340 /* 1 means the background of this string has been drawn. */
2341 unsigned background_filled_p
: 1;
2343 /* 1 means glyph string must be drawn with 16-bit functions. */
2344 unsigned two_byte_p
: 1;
2346 /* 1 means that the original font determined for drawing this glyph
2347 string could not be loaded. The member `font' has been set to
2348 the frame's default font in this case. */
2349 unsigned font_not_found_p
: 1;
2351 /* 1 means that the face in which this glyph string is drawn has a
2353 unsigned stippled_p
: 1;
2355 /* 1 means only the foreground of this glyph string must be drawn,
2356 and we should use the physical height of the line this glyph
2357 string appears in as clip rect. */
2358 unsigned for_overlaps_p
: 1;
2360 /* The GC to use for drawing this glyph string. */
2363 /* A pointer to the first glyph in the string. This glyph
2364 corresponds to char2b[0]. Needed to draw rectangles if
2365 font_not_found_p is 1. */
2366 struct glyph
*first_glyph
;
2368 /* Image, if any. */
2371 struct glyph_string
*next
, *prev
;
2378 x_dump_glyph_string (s
)
2379 struct glyph_string
*s
;
2381 fprintf (stderr
, "glyph string\n");
2382 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2383 s
->x
, s
->y
, s
->width
, s
->height
);
2384 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2385 fprintf (stderr
, " hl = %d\n", s
->hl
);
2386 fprintf (stderr
, " left overhang = %d, right = %d\n",
2387 s
->left_overhang
, s
->right_overhang
);
2388 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2389 fprintf (stderr
, " extends to end of line = %d\n",
2390 s
->extends_to_end_of_line_p
);
2391 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2392 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2395 #endif /* GLYPH_DEBUG */
2399 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2400 struct glyph_string
**,
2401 struct glyph_string
*,
2402 struct glyph_string
*));
2403 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2404 struct glyph_string
**,
2405 struct glyph_string
*,
2406 struct glyph_string
*));
2407 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2408 struct glyph_string
**,
2409 struct glyph_string
*));
2410 static int x_left_overwritten
P_ ((struct glyph_string
*));
2411 static int x_left_overwriting
P_ ((struct glyph_string
*));
2412 static int x_right_overwritten
P_ ((struct glyph_string
*));
2413 static int x_right_overwriting
P_ ((struct glyph_string
*));
2414 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2416 static void x_init_glyph_string
P_ ((struct glyph_string
*,
2417 XChar2b
*, struct window
*,
2419 enum glyph_row_area
, int,
2420 enum draw_glyphs_face
));
2421 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2422 enum glyph_row_area
, int, int,
2423 enum draw_glyphs_face
, int *, int *, int));
2424 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2425 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2426 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2428 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2429 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2430 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2431 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2432 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2433 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2434 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2435 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2436 static void x_get_glyph_overhangs
P_ ((struct glyph
*, struct frame
*,
2438 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2439 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
2440 unsigned long *, double, int));
2441 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2442 double, int, unsigned long));
2443 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2444 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2445 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2446 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2447 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
2448 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2449 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2451 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2452 int, int, int, int, XRectangle
*));
2453 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2454 int, int, int, XRectangle
*));
2455 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2456 enum glyph_row_area
));
2459 /* Append the list of glyph strings with head H and tail T to the list
2460 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2463 x_append_glyph_string_lists (head
, tail
, h
, t
)
2464 struct glyph_string
**head
, **tail
;
2465 struct glyph_string
*h
, *t
;
2479 /* Prepend the list of glyph strings with head H and tail T to the
2480 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2484 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2485 struct glyph_string
**head
, **tail
;
2486 struct glyph_string
*h
, *t
;
2500 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2501 Set *HEAD and *TAIL to the resulting list. */
2504 x_append_glyph_string (head
, tail
, s
)
2505 struct glyph_string
**head
, **tail
;
2506 struct glyph_string
*s
;
2508 s
->next
= s
->prev
= NULL
;
2509 x_append_glyph_string_lists (head
, tail
, s
, s
);
2513 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2518 struct glyph_string
*s
;
2520 if (s
->font
== FRAME_FONT (s
->f
)
2521 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2522 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2524 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
2527 /* Cursor on non-default face: must merge. */
2531 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
2532 xgcv
.foreground
= s
->face
->background
;
2534 /* If the glyph would be invisible, try a different foreground. */
2535 if (xgcv
.foreground
== xgcv
.background
)
2536 xgcv
.foreground
= s
->face
->foreground
;
2537 if (xgcv
.foreground
== xgcv
.background
)
2538 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
2539 if (xgcv
.foreground
== xgcv
.background
)
2540 xgcv
.foreground
= s
->face
->foreground
;
2542 /* Make sure the cursor is distinct from text in this face. */
2543 if (xgcv
.background
== s
->face
->background
2544 && xgcv
.foreground
== s
->face
->foreground
)
2546 xgcv
.background
= s
->face
->foreground
;
2547 xgcv
.foreground
= s
->face
->background
;
2550 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2551 xgcv
.font
= s
->font
->fid
;
2552 xgcv
.graphics_exposures
= False
;
2553 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2555 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2556 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2559 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2560 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2562 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2567 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2570 x_set_mouse_face_gc (s
)
2571 struct glyph_string
*s
;
2576 /* What face has to be used for the mouse face? */
2577 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2578 face
= FACE_FROM_ID (s
->f
, face_id
);
2579 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2580 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2581 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2583 /* If font in this face is same as S->font, use it. */
2584 if (s
->font
== s
->face
->font
)
2585 s
->gc
= s
->face
->gc
;
2588 /* Otherwise construct scratch_cursor_gc with values from FACE
2593 xgcv
.background
= s
->face
->background
;
2594 xgcv
.foreground
= s
->face
->foreground
;
2595 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2596 xgcv
.font
= s
->font
->fid
;
2597 xgcv
.graphics_exposures
= False
;
2598 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
2600 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2601 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2604 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2605 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2607 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2610 xassert (s
->gc
!= 0);
2614 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2615 Faces to use in the mode line have already been computed when the
2616 matrix was built, so there isn't much to do, here. */
2619 x_set_mode_line_face_gc (s
)
2620 struct glyph_string
*s
;
2622 s
->gc
= s
->face
->gc
;
2623 xassert (s
->gc
!= 0);
2627 /* Set S->gc of glyph string S for drawing that glyph string. Set
2628 S->stippled_p to a non-zero value if the face of S has a stipple
2632 x_set_glyph_string_gc (s
)
2633 struct glyph_string
*s
;
2635 if (s
->hl
== DRAW_NORMAL_TEXT
)
2637 s
->gc
= s
->face
->gc
;
2638 s
->stippled_p
= s
->face
->stipple
!= 0;
2640 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2642 x_set_mode_line_face_gc (s
);
2643 s
->stippled_p
= s
->face
->stipple
!= 0;
2645 else if (s
->hl
== DRAW_CURSOR
)
2647 x_set_cursor_gc (s
);
2650 else if (s
->hl
== DRAW_MOUSE_FACE
)
2652 x_set_mouse_face_gc (s
);
2653 s
->stippled_p
= s
->face
->stipple
!= 0;
2655 else if (s
->hl
== DRAW_IMAGE_RAISED
2656 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2658 s
->gc
= s
->face
->gc
;
2659 s
->stippled_p
= s
->face
->stipple
!= 0;
2663 s
->gc
= s
->face
->gc
;
2664 s
->stippled_p
= s
->face
->stipple
!= 0;
2667 /* GC must have been set. */
2668 xassert (s
->gc
!= 0);
2672 /* Return in *R the clipping rectangle for glyph string S. */
2675 x_get_glyph_string_clip_rect (s
, r
)
2676 struct glyph_string
*s
;
2679 if (s
->row
->full_width_p
)
2681 /* Draw full-width. X coordinates are relative to S->w->left. */
2682 int canon_x
= CANON_X_UNIT (s
->f
);
2684 r
->x
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
2685 r
->width
= XFASTINT (s
->w
->width
) * canon_x
;
2687 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
2689 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
2690 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
2694 r
->x
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
2696 /* Unless displaying a mode or menu bar line, which are always
2697 fully visible, clip to the visible part of the row. */
2698 if (s
->w
->pseudo_window_p
)
2699 r
->height
= s
->row
->visible_height
;
2701 r
->height
= s
->height
;
2705 /* This is a text line that may be partially visible. */
2706 r
->x
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
2707 r
->width
= window_box_width (s
->w
, s
->area
);
2708 r
->height
= s
->row
->visible_height
;
2711 /* Don't use S->y for clipping because it doesn't take partially
2712 visible lines into account. For example, it can be negative for
2713 partially visible lines at the top of a window. */
2714 if (!s
->row
->full_width_p
2715 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2716 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2718 r
->y
= max (0, s
->row
->y
);
2720 /* If drawing a tool-bar window, draw it over the internal border
2721 at the top of the window. */
2722 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
2723 r
->y
-= s
->f
->output_data
.x
->internal_border_width
;
2725 /* If S draws overlapping rows, it's sufficient to use the top and
2726 bottom of the window for clipping because this glyph string
2727 intentionally draws over other lines. */
2728 if (s
->for_overlaps_p
)
2730 r
->y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
2731 r
->height
= window_text_bottom_y (s
->w
) - r
->y
;
2734 r
->y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->y
);
2738 /* Set clipping for output of glyph string S. S may be part of a mode
2739 line or menu if we don't have X toolkit support. */
2742 x_set_glyph_string_clipping (s
)
2743 struct glyph_string
*s
;
2746 x_get_glyph_string_clip_rect (s
, &r
);
2747 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
2751 /* Compute left and right overhang of glyph string S. If S is a glyph
2752 string for a composition, assume overhangs don't exist. */
2755 x_compute_glyph_string_overhangs (s
)
2756 struct glyph_string
*s
;
2759 && s
->first_glyph
->type
== CHAR_GLYPH
)
2762 int direction
, font_ascent
, font_descent
;
2763 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
2764 &font_ascent
, &font_descent
, &cs
);
2765 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2766 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2771 /* Compute overhangs and x-positions for glyph string S and its
2772 predecessors, or successors. X is the starting x-position for S.
2773 BACKWARD_P non-zero means process predecessors. */
2776 x_compute_overhangs_and_x (s
, x
, backward_p
)
2777 struct glyph_string
*s
;
2785 x_compute_glyph_string_overhangs (s
);
2795 x_compute_glyph_string_overhangs (s
);
2804 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2805 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2806 assumed to be zero. */
2809 x_get_glyph_overhangs (glyph
, f
, left
, right
)
2810 struct glyph
*glyph
;
2818 if (glyph
->type
== CHAR_GLYPH
)
2822 struct font_info
*font_info
;
2826 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
2828 font_info
= FONT_INFO_FROM_ID (f
, face
->font_info_id
);
2830 && (pcm
= x_per_char_metric (font
, &char2b
)))
2832 if (pcm
->rbearing
> pcm
->width
)
2833 *right
= pcm
->rbearing
- pcm
->width
;
2834 if (pcm
->lbearing
< 0)
2835 *left
= -pcm
->lbearing
;
2841 /* Return the index of the first glyph preceding glyph string S that
2842 is overwritten by S because of S's left overhang. Value is -1
2843 if no glyphs are overwritten. */
2846 x_left_overwritten (s
)
2847 struct glyph_string
*s
;
2851 if (s
->left_overhang
)
2854 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2855 int first
= s
->first_glyph
- glyphs
;
2857 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
2858 x
-= glyphs
[i
].pixel_width
;
2869 /* Return the index of the first glyph preceding glyph string S that
2870 is overwriting S because of its right overhang. Value is -1 if no
2871 glyph in front of S overwrites S. */
2874 x_left_overwriting (s
)
2875 struct glyph_string
*s
;
2878 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2879 int first
= s
->first_glyph
- glyphs
;
2883 for (i
= first
- 1; i
>= 0; --i
)
2886 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
2889 x
-= glyphs
[i
].pixel_width
;
2896 /* Return the index of the last glyph following glyph string S that is
2897 not overwritten by S because of S's right overhang. Value is -1 if
2898 no such glyph is found. */
2901 x_right_overwritten (s
)
2902 struct glyph_string
*s
;
2906 if (s
->right_overhang
)
2909 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2910 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
2911 int end
= s
->row
->used
[s
->area
];
2913 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
2914 x
+= glyphs
[i
].pixel_width
;
2923 /* Return the index of the last glyph following glyph string S that
2924 overwrites S because of its left overhang. Value is negative
2925 if no such glyph is found. */
2928 x_right_overwriting (s
)
2929 struct glyph_string
*s
;
2932 int end
= s
->row
->used
[s
->area
];
2933 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
2934 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
2938 for (i
= first
; i
< end
; ++i
)
2941 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
2944 x
+= glyphs
[i
].pixel_width
;
2951 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
2954 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
2955 struct glyph_string
*s
;
2959 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
2960 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2961 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2962 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2966 /* Draw the background of glyph_string S. If S->background_filled_p
2967 is non-zero don't draw it. FORCE_P non-zero means draw the
2968 background even if it wouldn't be drawn normally. This is used
2969 when a string preceding S draws into the background of S, or S
2970 contains the first component of a composition. */
2973 x_draw_glyph_string_background (s
, force_p
)
2974 struct glyph_string
*s
;
2977 /* Nothing to do if background has already been drawn or if it
2978 shouldn't be drawn in the first place. */
2979 if (!s
->background_filled_p
)
2983 /* Fill background with a stipple pattern. */
2984 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2985 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
2986 s
->y
+ s
->face
->box_line_width
,
2987 s
->background_width
,
2988 s
->height
- 2 * s
->face
->box_line_width
);
2989 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2990 s
->background_filled_p
= 1;
2992 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * s
->face
->box_line_width
2993 || s
->font_not_found_p
2994 || s
->extends_to_end_of_line_p
2997 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ s
->face
->box_line_width
,
2998 s
->background_width
,
2999 s
->height
- 2 * s
->face
->box_line_width
);
3000 s
->background_filled_p
= 1;
3006 /* Draw the foreground of glyph string S. */
3009 x_draw_glyph_string_foreground (s
)
3010 struct glyph_string
*s
;
3014 /* If first glyph of S has a left box line, start drawing the text
3015 of S to the right of that box line. */
3016 if (s
->face
->box
!= FACE_NO_BOX
3017 && s
->first_glyph
->left_box_line_p
)
3018 x
= s
->x
+ s
->face
->box_line_width
;
3022 /* Draw characters of S as rectangles if S's font could not be
3024 if (s
->font_not_found_p
)
3026 for (i
= 0; i
< s
->nchars
; ++i
)
3028 struct glyph
*g
= s
->first_glyph
+ i
;
3029 XDrawRectangle (s
->display
, s
->window
,
3030 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3032 x
+= g
->pixel_width
;
3037 char *char1b
= (char *) s
->char2b
;
3038 int boff
= s
->font_info
->baseline_offset
;
3040 if (s
->font_info
->vertical_centering
)
3041 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3043 /* If we can use 8-bit functions, condense S->char2b. */
3045 for (i
= 0; i
< s
->nchars
; ++i
)
3046 char1b
[i
] = s
->char2b
[i
].byte2
;
3048 /* Draw text with XDrawString if background has already been
3049 filled. Otherwise, use XDrawImageString. (Note that
3050 XDrawImageString is usually faster than XDrawString.) Always
3051 use XDrawImageString when drawing the cursor so that there is
3052 no chance that characters under a box cursor are invisible. */
3053 if (s
->for_overlaps_p
3054 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3056 /* Draw characters with 16-bit or 8-bit functions. */
3058 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
3059 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3061 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
3062 s
->ybase
- boff
, char1b
, s
->nchars
);
3067 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
3068 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3070 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
3071 s
->ybase
- boff
, char1b
, s
->nchars
);
3076 /* Draw the foreground of composite glyph string S. */
3079 x_draw_composite_glyph_string_foreground (s
)
3080 struct glyph_string
*s
;
3084 /* If first glyph of S has a left box line, start drawing the text
3085 of S to the right of that box line. */
3086 if (s
->face
->box
!= FACE_NO_BOX
3087 && s
->first_glyph
->left_box_line_p
)
3088 x
= s
->x
+ s
->face
->box_line_width
;
3092 /* S is a glyph string for a composition. S->gidx is the index of
3093 the first character drawn for glyphs of this composition.
3094 S->gidx == 0 means we are drawing the very first character of
3095 this composition. */
3097 /* Draw a rectangle for the composition if the font for the very
3098 first character of the composition could not be loaded. */
3099 if (s
->font_not_found_p
)
3102 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
3103 s
->width
- 1, s
->height
- 1);
3107 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3108 XDrawString16 (s
->display
, s
->window
, s
->gc
,
3109 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3110 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3116 #ifdef USE_X_TOOLKIT
3118 /* Allocate the color COLOR->pixel on the screen and display of
3119 widget WIDGET in colormap CMAP. If an exact match cannot be
3120 allocated, try the nearest color available. Value is non-zero
3121 if successful. This is called from lwlib. */
3124 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3130 struct x_display_info
*dpyinfo
;
3133 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3135 /* Find the top-level shell of the widget. Note that this function
3136 can be called when the widget is not yet realized, so XtWindow
3137 (widget) == 0. That's the reason we can't simply use
3138 x_any_window_to_frame. */
3139 while (!XtIsTopLevelShell (widget
))
3140 widget
= XtParent (widget
);
3142 /* Look for a frame with that top-level widget. Allocate the color
3143 on that frame to get the right gamma correction value. */
3144 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3145 if (GC_FRAMEP (XCAR (tail
))
3146 && (f
= XFRAME (XCAR (tail
)),
3147 (f
->output_data
.nothing
!= 1
3148 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3149 && f
->output_data
.x
->widget
== widget
)
3150 return x_alloc_nearest_color (f
, cmap
, color
);
3155 #endif /* USE_X_TOOLKIT */
3158 /* Allocate the color COLOR->pixel on SCREEN of DISPLAY, colormap
3159 CMAP. If an exact match can't be allocated, try the nearest color
3160 available. Value is non-zero if successful. Set *COLOR to the
3164 x_alloc_nearest_color (f
, cmap
, color
)
3169 Display
*display
= FRAME_X_DISPLAY (f
);
3170 Screen
*screen
= FRAME_X_SCREEN (f
);
3173 gamma_correct (f
, color
);
3174 rc
= XAllocColor (display
, cmap
, color
);
3177 /* If we got to this point, the colormap is full, so we're going
3178 to try to get the next closest color. The algorithm used is
3179 a least-squares matching, which is what X uses for closest
3180 color matching with StaticColor visuals. */
3182 unsigned long nearest_delta
= ~0;
3183 int ncells
= XDisplayCells (display
, XScreenNumberOfScreen (screen
));
3184 XColor
*cells
= (XColor
*) alloca (ncells
* sizeof *cells
);
3186 for (i
= 0; i
< ncells
; ++i
)
3188 XQueryColors (display
, cmap
, cells
, ncells
);
3190 for (nearest
= i
= 0; i
< ncells
; ++i
)
3192 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3193 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3194 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3195 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3197 if (delta
< nearest_delta
)
3200 nearest_delta
= delta
;
3204 color
->red
= cells
[nearest
].red
;
3205 color
->green
= cells
[nearest
].green
;
3206 color
->blue
= cells
[nearest
].blue
;
3207 rc
= XAllocColor (display
, cmap
, color
);
3210 #ifdef DEBUG_X_COLORS
3212 register_color (color
->pixel
);
3213 #endif /* DEBUG_X_COLORS */
3219 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3220 It's necessary to do this instead of just using PIXEL directly to
3221 get color reference counts right. */
3224 x_copy_color (f
, pixel
)
3226 unsigned long pixel
;
3230 color
.pixel
= pixel
;
3232 XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3233 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3235 #ifdef DEBUG_X_COLORS
3236 register_color (pixel
);
3242 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3243 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3244 If this produces the same color as PIXEL, try a color where all RGB
3245 values have DELTA added. Return the allocated color in *PIXEL.
3246 DISPLAY is the X display, CMAP is the colormap to operate on.
3247 Value is non-zero if successful. */
3250 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
3254 unsigned long *pixel
;
3261 /* Get RGB color values. */
3262 color
.pixel
= *pixel
;
3263 XQueryColor (display
, cmap
, &color
);
3265 /* Change RGB values by specified FACTOR. Avoid overflow! */
3266 xassert (factor
>= 0);
3267 new.red
= min (0xffff, factor
* color
.red
);
3268 new.green
= min (0xffff, factor
* color
.green
);
3269 new.blue
= min (0xffff, factor
* color
.blue
);
3271 /* Try to allocate the color. */
3272 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3275 if (new.pixel
== *pixel
)
3277 /* If we end up with the same color as before, try adding
3278 delta to the RGB values. */
3279 x_free_colors (f
, &new.pixel
, 1);
3281 new.red
= min (0xffff, delta
+ color
.red
);
3282 new.green
= min (0xffff, delta
+ color
.green
);
3283 new.blue
= min (0xffff, delta
+ color
.blue
);
3284 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
3295 /* Set up the foreground color for drawing relief lines of glyph
3296 string S. RELIEF is a pointer to a struct relief containing the GC
3297 with which lines will be drawn. Use a color that is FACTOR or
3298 DELTA lighter or darker than the relief's background which is found
3299 in S->f->output_data.x->relief_background. If such a color cannot
3300 be allocated, use DEFAULT_PIXEL, instead. */
3303 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3305 struct relief
*relief
;
3308 unsigned long default_pixel
;
3311 struct x_output
*di
= f
->output_data
.x
;
3312 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
3313 unsigned long pixel
;
3314 unsigned long background
= di
->relief_background
;
3315 Colormap cmap
= FRAME_X_COLORMAP (f
);
3316 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3317 Display
*dpy
= FRAME_X_DISPLAY (f
);
3319 xgcv
.graphics_exposures
= False
;
3320 xgcv
.line_width
= 1;
3322 /* Free previously allocated color. The color cell will be reused
3323 when it has been freed as many times as it was allocated, so this
3324 doesn't affect faces using the same colors. */
3326 && relief
->allocated_p
)
3328 /* If display has an immutable color map, freeing colors is not
3329 necessary and some servers don't allow it. So don't do it. */
3330 x_free_colors (f
, &relief
->pixel
, 1);
3331 relief
->allocated_p
= 0;
3334 /* Allocate new color. */
3335 xgcv
.foreground
= default_pixel
;
3337 if (dpyinfo
->n_planes
!= 1
3338 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
3340 relief
->allocated_p
= 1;
3341 xgcv
.foreground
= relief
->pixel
= pixel
;
3344 if (relief
->gc
== 0)
3346 xgcv
.stipple
= dpyinfo
->gray
;
3348 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
3351 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
3355 /* Set up colors for the relief lines around glyph string S. */
3358 x_setup_relief_colors (s
)
3359 struct glyph_string
*s
;
3361 struct x_output
*di
= s
->f
->output_data
.x
;
3362 unsigned long color
;
3364 if (s
->face
->use_box_color_for_shadows_p
)
3365 color
= s
->face
->box_color
;
3370 /* Get the background color of the face. */
3371 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3372 color
= xgcv
.background
;
3375 if (di
->white_relief
.gc
== 0
3376 || color
!= di
->relief_background
)
3378 di
->relief_background
= color
;
3379 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3380 WHITE_PIX_DEFAULT (s
->f
));
3381 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3382 BLACK_PIX_DEFAULT (s
->f
));
3387 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3388 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3389 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3390 relief. LEFT_P non-zero means draw a relief on the left side of
3391 the rectangle. RIGHT_P non-zero means draw a relief on the right
3392 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3396 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3397 raised_p
, left_p
, right_p
, clip_rect
)
3399 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3400 XRectangle
*clip_rect
;
3406 gc
= f
->output_data
.x
->white_relief
.gc
;
3408 gc
= f
->output_data
.x
->black_relief
.gc
;
3409 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3412 for (i
= 0; i
< width
; ++i
)
3413 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3414 left_x
+ i
* left_p
, top_y
+ i
,
3415 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3419 for (i
= 0; i
< width
; ++i
)
3420 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3421 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
);
3423 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3425 gc
= f
->output_data
.x
->black_relief
.gc
;
3427 gc
= f
->output_data
.x
->white_relief
.gc
;
3428 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, clip_rect
, 1, Unsorted
);
3431 for (i
= 0; i
< width
; ++i
)
3432 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3433 left_x
+ i
* left_p
, bottom_y
- i
,
3434 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3438 for (i
= 0; i
< width
; ++i
)
3439 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3440 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3442 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
3446 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3447 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3448 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3449 left side of the rectangle. RIGHT_P non-zero means draw a line
3450 on the right side of the rectangle. CLIP_RECT is the clipping
3451 rectangle to use when drawing. */
3454 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3455 left_p
, right_p
, clip_rect
)
3456 struct glyph_string
*s
;
3457 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
;
3458 XRectangle
*clip_rect
;
3462 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3463 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3464 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
3467 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3468 left_x
, top_y
, right_x
- left_x
, width
);
3472 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3473 left_x
, top_y
, width
, bottom_y
- top_y
);
3476 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3477 left_x
, bottom_y
- width
, right_x
- left_x
, width
);
3481 XFillRectangle (s
->display
, s
->window
, s
->gc
,
3482 right_x
- width
, top_y
, width
, bottom_y
- top_y
);
3484 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3485 XSetClipMask (s
->display
, s
->gc
, None
);
3489 /* Draw a box around glyph string S. */
3492 x_draw_glyph_string_box (s
)
3493 struct glyph_string
*s
;
3495 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3496 int left_p
, right_p
;
3497 struct glyph
*last_glyph
;
3498 XRectangle clip_rect
;
3500 last_x
= window_box_right (s
->w
, s
->area
);
3501 if (s
->row
->full_width_p
3502 && !s
->w
->pseudo_window_p
)
3504 last_x
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s
->f
);
3505 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
3506 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
3509 /* The glyph that may have a right box line. */
3510 last_glyph
= (s
->cmp
|| s
->img
3512 : s
->first_glyph
+ s
->nchars
- 1);
3514 width
= s
->face
->box_line_width
;
3515 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3517 right_x
= ((s
->row
->full_width_p
3519 : min (last_x
, s
->x
+ s
->background_width
) - 1));
3521 bottom_y
= top_y
+ s
->height
- 1;
3523 left_p
= (s
->first_glyph
->left_box_line_p
3524 || (s
->hl
== DRAW_MOUSE_FACE
3526 || s
->prev
->hl
!= s
->hl
)));
3527 right_p
= (last_glyph
->right_box_line_p
3528 || (s
->hl
== DRAW_MOUSE_FACE
3530 || s
->next
->hl
!= s
->hl
)));
3532 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3534 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3535 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3536 left_p
, right_p
, &clip_rect
);
3539 x_setup_relief_colors (s
);
3540 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3541 width
, raised_p
, left_p
, right_p
, &clip_rect
);
3546 /* Draw foreground of image glyph string S. */
3549 x_draw_image_foreground (s
)
3550 struct glyph_string
*s
;
3553 int y
= s
->ybase
- IMAGE_ASCENT (s
->img
);
3555 /* If first glyph of S has a left box line, start drawing it to the
3556 right of that line. */
3557 if (s
->face
->box
!= FACE_NO_BOX
3558 && s
->first_glyph
->left_box_line_p
)
3559 x
= s
->x
+ s
->face
->box_line_width
;
3563 /* If there is a margin around the image, adjust x- and y-position
3567 x
+= s
->img
->margin
;
3568 y
+= s
->img
->margin
;
3575 /* We can't set both a clip mask and use XSetClipRectangles
3576 because the latter also sets a clip mask. We also can't
3577 trust on the shape extension to be available
3578 (XShapeCombineRegion). So, compute the rectangle to draw
3580 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3583 XRectangle clip_rect
, image_rect
, r
;
3585 xgcv
.clip_mask
= s
->img
->mask
;
3586 xgcv
.clip_x_origin
= x
;
3587 xgcv
.clip_y_origin
= y
;
3588 xgcv
.function
= GXcopy
;
3589 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3591 x_get_glyph_string_clip_rect (s
, &clip_rect
);
3594 image_rect
.width
= s
->img
->width
;
3595 image_rect
.height
= s
->img
->height
;
3596 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
3597 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3598 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
3602 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3603 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3605 /* When the image has a mask, we can expect that at
3606 least part of a mouse highlight or a block cursor will
3607 be visible. If the image doesn't have a mask, make
3608 a block cursor visible by drawing a rectangle around
3609 the image. I believe it's looking better if we do
3610 nothing here for mouse-face. */
3611 if (s
->hl
== DRAW_CURSOR
)
3612 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
3613 s
->img
->width
- 1, s
->img
->height
- 1);
3617 /* Draw a rectangle if image could not be loaded. */
3618 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
3619 s
->img
->width
- 1, s
->img
->height
- 1);
3623 /* Draw a relief around the image glyph string S. */
3626 x_draw_image_relief (s
)
3627 struct glyph_string
*s
;
3629 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3632 int y
= s
->ybase
- IMAGE_ASCENT (s
->img
);
3634 /* If first glyph of S has a left box line, start drawing it to the
3635 right of that line. */
3636 if (s
->face
->box
!= FACE_NO_BOX
3637 && s
->first_glyph
->left_box_line_p
)
3638 x
= s
->x
+ s
->face
->box_line_width
;
3642 /* If there is a margin around the image, adjust x- and y-position
3646 x
+= s
->img
->margin
;
3647 y
+= s
->img
->margin
;
3650 if (s
->hl
== DRAW_IMAGE_SUNKEN
3651 || s
->hl
== DRAW_IMAGE_RAISED
)
3653 thick
= tool_bar_button_relief
> 0 ? tool_bar_button_relief
: 3;
3654 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3658 thick
= abs (s
->img
->relief
);
3659 raised_p
= s
->img
->relief
> 0;
3664 x1
= x
+ s
->img
->width
+ thick
- 1;
3665 y1
= y
+ s
->img
->height
+ thick
- 1;
3667 x_setup_relief_colors (s
);
3668 x_get_glyph_string_clip_rect (s
, &r
);
3669 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
3673 /* Draw the foreground of image glyph string S to PIXMAP. */
3676 x_draw_image_foreground_1 (s
, pixmap
)
3677 struct glyph_string
*s
;
3681 int y
= s
->ybase
- s
->y
- IMAGE_ASCENT (s
->img
);
3683 /* If first glyph of S has a left box line, start drawing it to the
3684 right of that line. */
3685 if (s
->face
->box
!= FACE_NO_BOX
3686 && s
->first_glyph
->left_box_line_p
)
3687 x
= s
->face
->box_line_width
;
3691 /* If there is a margin around the image, adjust x- and y-position
3695 x
+= s
->img
->margin
;
3696 y
+= s
->img
->margin
;
3703 /* We can't set both a clip mask and use XSetClipRectangles
3704 because the latter also sets a clip mask. We also can't
3705 trust on the shape extension to be available
3706 (XShapeCombineRegion). So, compute the rectangle to draw
3708 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3712 xgcv
.clip_mask
= s
->img
->mask
;
3713 xgcv
.clip_x_origin
= x
;
3714 xgcv
.clip_y_origin
= y
;
3715 xgcv
.function
= GXcopy
;
3716 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3718 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3719 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3720 XSetClipMask (s
->display
, s
->gc
, None
);
3724 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3725 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3727 /* When the image has a mask, we can expect that at
3728 least part of a mouse highlight or a block cursor will
3729 be visible. If the image doesn't have a mask, make
3730 a block cursor visible by drawing a rectangle around
3731 the image. I believe it's looking better if we do
3732 nothing here for mouse-face. */
3733 if (s
->hl
== DRAW_CURSOR
)
3734 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
3735 s
->img
->width
- 1, s
->img
->height
- 1);
3739 /* Draw a rectangle if image could not be loaded. */
3740 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
3741 s
->img
->width
- 1, s
->img
->height
- 1);
3745 /* Draw part of the background of glyph string S. X, Y, W, and H
3746 give the rectangle to draw. */
3749 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
3750 struct glyph_string
*s
;
3755 /* Fill background with a stipple pattern. */
3756 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3757 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3758 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3761 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
3765 /* Draw image glyph string S.
3768 s->x +-------------------------
3771 | +-------------------------
3774 | | +-------------------
3780 x_draw_image_glyph_string (s
)
3781 struct glyph_string
*s
;
3784 int box_line_width
= s
->face
->box_line_width
;
3785 int margin
= s
->img
->margin
;
3787 Pixmap pixmap
= None
;
3789 height
= s
->height
- 2 * box_line_width
;
3791 /* Fill background with face under the image. Do it only if row is
3792 taller than image or if image has a clip mask to reduce
3794 s
->stippled_p
= s
->face
->stipple
!= 0;
3795 if (height
> s
->img
->height
3798 || s
->img
->pixmap
== 0
3799 || s
->width
!= s
->background_width
)
3801 if (box_line_width
&& s
->first_glyph
->left_box_line_p
)
3802 x
= s
->x
+ box_line_width
;
3806 y
= s
->y
+ box_line_width
;
3810 /* Create a pixmap as large as the glyph string Fill it with
3811 the background color. Copy the image to it, using its
3812 mask. Copy the temporary pixmap to the display. */
3813 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
3814 int depth
= DefaultDepthOfScreen (screen
);
3816 /* Create a pixmap as large as the glyph string. */
3817 pixmap
= XCreatePixmap (s
->display
, s
->window
,
3818 s
->background_width
,
3821 /* Don't clip in the following because we're working on the
3823 XSetClipMask (s
->display
, s
->gc
, None
);
3825 /* Fill the pixmap with the background color/stipple. */
3828 /* Fill background with a stipple pattern. */
3829 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3830 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3831 0, 0, s
->background_width
, s
->height
);
3832 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3837 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
3839 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3840 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3841 0, 0, s
->background_width
, s
->height
);
3842 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3846 /* Implementation idea: Is it possible to construct a mask?
3847 We could look at the color at the margins of the image, and
3848 say that this color is probably the background color of the
3850 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
3852 s
->background_filled_p
= 1;
3855 /* Draw the foreground. */
3858 x_draw_image_foreground_1 (s
, pixmap
);
3859 x_set_glyph_string_clipping (s
);
3860 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
3861 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
3862 XFreePixmap (s
->display
, pixmap
);
3865 x_draw_image_foreground (s
);
3867 /* If we must draw a relief around the image, do it. */
3869 || s
->hl
== DRAW_IMAGE_RAISED
3870 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3871 x_draw_image_relief (s
);
3875 /* Draw stretch glyph string S. */
3878 x_draw_stretch_glyph_string (s
)
3879 struct glyph_string
*s
;
3881 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
3882 s
->stippled_p
= s
->face
->stipple
!= 0;
3884 if (s
->hl
== DRAW_CURSOR
3885 && !x_stretch_cursor_p
)
3887 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
3888 as wide as the stretch glyph. */
3889 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
3892 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
3894 /* Clear rest using the GC of the original non-cursor face. */
3895 if (width
< s
->background_width
)
3897 GC gc
= s
->face
->gc
;
3898 int x
= s
->x
+ width
, y
= s
->y
;
3899 int w
= s
->background_width
- width
, h
= s
->height
;
3902 x_get_glyph_string_clip_rect (s
, &r
);
3903 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
3905 if (s
->face
->stipple
)
3907 /* Fill background with a stipple pattern. */
3908 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
3909 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
3910 XSetFillStyle (s
->display
, gc
, FillSolid
);
3915 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
3916 XSetForeground (s
->display
, gc
, xgcv
.background
);
3917 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
3918 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
3923 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
3926 s
->background_filled_p
= 1;
3930 /* Draw glyph string S. */
3933 x_draw_glyph_string (s
)
3934 struct glyph_string
*s
;
3936 /* If S draws into the background of its successor, draw the
3937 background of the successor first so that S can draw into it.
3938 This makes S->next use XDrawString instead of XDrawImageString. */
3939 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
3941 xassert (s
->next
->img
== NULL
);
3942 x_set_glyph_string_gc (s
->next
);
3943 x_set_glyph_string_clipping (s
->next
);
3944 x_draw_glyph_string_background (s
->next
, 1);
3947 /* Set up S->gc, set clipping and draw S. */
3948 x_set_glyph_string_gc (s
);
3949 x_set_glyph_string_clipping (s
);
3951 switch (s
->first_glyph
->type
)
3954 x_draw_image_glyph_string (s
);
3958 x_draw_stretch_glyph_string (s
);
3962 if (s
->for_overlaps_p
)
3963 s
->background_filled_p
= 1;
3965 x_draw_glyph_string_background (s
, 0);
3966 x_draw_glyph_string_foreground (s
);
3969 case COMPOSITE_GLYPH
:
3970 if (s
->for_overlaps_p
|| s
->gidx
> 0)
3971 s
->background_filled_p
= 1;
3973 x_draw_glyph_string_background (s
, 1);
3974 x_draw_composite_glyph_string_foreground (s
);
3981 if (!s
->for_overlaps_p
)
3983 /* Draw underline. */
3984 if (s
->face
->underline_p
)
3986 unsigned long dy
, h
;
3988 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
3990 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &dy
))
3993 if (s
->face
->underline_defaulted_p
)
3994 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
3999 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4000 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
4001 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4003 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4007 /* Draw overline. */
4008 if (s
->face
->overline_p
)
4010 unsigned long dy
= 0, h
= 1;
4012 if (s
->face
->overline_color_defaulted_p
)
4013 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4018 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4019 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4020 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4022 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4026 /* Draw strike-through. */
4027 if (s
->face
->strike_through_p
)
4029 unsigned long h
= 1;
4030 unsigned long dy
= (s
->height
- h
) / 2;
4032 if (s
->face
->strike_through_color_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
->strike_through_color
);
4040 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4042 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4047 if (s
->face
->box
!= FACE_NO_BOX
)
4048 x_draw_glyph_string_box (s
);
4051 /* Reset clipping. */
4052 XSetClipMask (s
->display
, s
->gc
, None
);
4056 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4057 struct face
**, int));
4060 /* Load glyph string S with a composition components specified by S->cmp.
4061 FACES is an array of faces for all components of this composition.
4062 S->gidx is the index of the first component for S.
4063 OVERLAPS_P non-zero means S should draw the foreground only, and
4064 use its lines physical height for clipping.
4066 Value is the index of a component not in S. */
4069 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4070 struct glyph_string
*s
;
4071 struct face
**faces
;
4078 s
->for_overlaps_p
= overlaps_p
;
4080 s
->face
= faces
[s
->gidx
];
4081 s
->font
= s
->face
->font
;
4082 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4084 /* For all glyphs of this composition, starting at the offset
4085 S->gidx, until we reach the end of the definition or encounter a
4086 glyph that requires the different face, add it to S. */
4088 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4091 /* All glyph strings for the same composition has the same width,
4092 i.e. the width set for the first component of the composition. */
4094 s
->width
= s
->first_glyph
->pixel_width
;
4096 /* If the specified font could not be loaded, use the frame's
4097 default font, but record the fact that we couldn't load it in
4098 the glyph string so that we can draw rectangles for the
4099 characters of the glyph string. */
4100 if (s
->font
== NULL
)
4102 s
->font_not_found_p
= 1;
4103 s
->font
= FRAME_FONT (s
->f
);
4106 /* Adjust base line for subscript/superscript text. */
4107 s
->ybase
+= s
->first_glyph
->voffset
;
4109 xassert (s
->face
&& s
->face
->gc
);
4111 /* This glyph string must always be drawn with 16-bit functions. */
4114 return s
->gidx
+ s
->nchars
;
4118 /* Load glyph string S with a sequence characters.
4119 FACE_ID is the face id of the string. START is the index of the
4120 first glyph to consider, END is the index of the last + 1.
4121 OVERLAPS_P non-zero means S should draw the foreground only, and
4122 use its lines physical height for clipping.
4124 Value is the index of the first glyph not in S. */
4127 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4128 struct glyph_string
*s
;
4130 int start
, end
, overlaps_p
;
4132 struct glyph
*glyph
, *last
;
4134 int glyph_not_available_p
;
4136 xassert (s
->f
== XFRAME (s
->w
->frame
));
4137 xassert (s
->nchars
== 0);
4138 xassert (start
>= 0 && end
> start
);
4140 s
->for_overlaps_p
= overlaps_p
,
4141 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4142 last
= s
->row
->glyphs
[s
->area
] + end
;
4143 voffset
= glyph
->voffset
;
4145 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4148 && glyph
->type
== CHAR_GLYPH
4149 && glyph
->voffset
== voffset
4150 /* Same face id implies same font, nowadays. */
4151 && glyph
->face_id
== face_id
4152 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4156 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4157 s
->char2b
+ s
->nchars
,
4159 s
->two_byte_p
= two_byte_p
;
4161 xassert (s
->nchars
<= end
- start
);
4162 s
->width
+= glyph
->pixel_width
;
4166 s
->font
= s
->face
->font
;
4167 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4169 /* If the specified font could not be loaded, use the frame's font,
4170 but record the fact that we couldn't load it in
4171 S->font_not_found_p so that we can draw rectangles for the
4172 characters of the glyph string. */
4173 if (s
->font
== NULL
|| glyph_not_available_p
)
4175 s
->font_not_found_p
= 1;
4176 s
->font
= FRAME_FONT (s
->f
);
4179 /* Adjust base line for subscript/superscript text. */
4180 s
->ybase
+= voffset
;
4182 xassert (s
->face
&& s
->face
->gc
);
4183 return glyph
- s
->row
->glyphs
[s
->area
];
4187 /* Fill glyph string S from image glyph S->first_glyph. */
4190 x_fill_image_glyph_string (s
)
4191 struct glyph_string
*s
;
4193 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4194 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4196 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4197 s
->font
= s
->face
->font
;
4198 s
->width
= s
->first_glyph
->pixel_width
;
4200 /* Adjust base line for subscript/superscript text. */
4201 s
->ybase
+= s
->first_glyph
->voffset
;
4205 /* Fill glyph string S from stretch glyph S->first_glyph. */
4208 x_fill_stretch_glyph_string (s
)
4209 struct glyph_string
*s
;
4211 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4212 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4213 s
->font
= s
->face
->font
;
4214 s
->width
= s
->first_glyph
->pixel_width
;
4216 /* Adjust base line for subscript/superscript text. */
4217 s
->ybase
+= s
->first_glyph
->voffset
;
4221 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4222 of XChar2b structures for S; it can't be allocated in
4223 x_init_glyph_string because it must be allocated via `alloca'. W
4224 is the window on which S is drawn. ROW and AREA are the glyph row
4225 and area within the row from which S is constructed. START is the
4226 index of the first glyph structure covered by S. HL is a
4227 face-override for drawing S. */
4230 x_init_glyph_string (s
, char2b
, w
, row
, area
, start
, hl
)
4231 struct glyph_string
*s
;
4234 struct glyph_row
*row
;
4235 enum glyph_row_area area
;
4237 enum draw_glyphs_face hl
;
4239 bzero (s
, sizeof *s
);
4241 s
->f
= XFRAME (w
->frame
);
4242 s
->display
= FRAME_X_DISPLAY (s
->f
);
4243 s
->window
= FRAME_X_WINDOW (s
->f
);
4248 s
->first_glyph
= row
->glyphs
[area
] + start
;
4249 s
->height
= row
->height
;
4250 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4252 /* Display the internal border below the tool-bar window. */
4253 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4254 s
->y
-= s
->f
->output_data
.x
->internal_border_width
;
4256 s
->ybase
= s
->y
+ row
->ascent
;
4260 /* Set background width of glyph string S. START is the index of the
4261 first glyph following S. LAST_X is the right-most x-position + 1
4262 in the drawing area. */
4265 x_set_glyph_string_background_width (s
, start
, last_x
)
4266 struct glyph_string
*s
;
4270 /* If the face of this glyph string has to be drawn to the end of
4271 the drawing area, set S->extends_to_end_of_line_p. */
4272 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4274 if (start
== s
->row
->used
[s
->area
]
4275 && s
->hl
== DRAW_NORMAL_TEXT
4276 && ((s
->area
== TEXT_AREA
&& s
->row
->fill_line_p
)
4277 || s
->face
->background
!= default_face
->background
4278 || s
->face
->stipple
!= default_face
->stipple
))
4279 s
->extends_to_end_of_line_p
= 1;
4281 /* If S extends its face to the end of the line, set its
4282 background_width to the distance to the right edge of the drawing
4284 if (s
->extends_to_end_of_line_p
)
4285 s
->background_width
= last_x
- s
->x
+ 1;
4287 s
->background_width
= s
->width
;
4291 /* Add a glyph string for a stretch glyph to the list of strings
4292 between HEAD and TAIL. START is the index of the stretch glyph in
4293 row area AREA of glyph row ROW. END is the index of the last glyph
4294 in that glyph row area. X is the current output position assigned
4295 to the new glyph string constructed. HL overrides that face of the
4296 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4297 is the right-most x-position of the drawing area. */
4299 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4300 and below -- keep them on one line. */
4301 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4304 s = (struct glyph_string *) alloca (sizeof *s); \
4305 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4306 x_fill_stretch_glyph_string (s); \
4307 x_append_glyph_string (&HEAD, &TAIL, s); \
4314 /* Add a glyph string for an image glyph to the list of strings
4315 between HEAD and TAIL. START is the index of the image glyph in
4316 row area AREA of glyph row ROW. END is the index of the last glyph
4317 in that glyph row area. X is the current output position assigned
4318 to the new glyph string constructed. HL overrides that face of the
4319 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4320 is the right-most x-position of the drawing area. */
4322 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4325 s = (struct glyph_string *) alloca (sizeof *s); \
4326 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4327 x_fill_image_glyph_string (s); \
4328 x_append_glyph_string (&HEAD, &TAIL, s); \
4335 /* Add a glyph string for a sequence of character glyphs to the list
4336 of strings between HEAD and TAIL. START is the index of the first
4337 glyph in row area AREA of glyph row ROW that is part of the new
4338 glyph string. END is the index of the last glyph in that glyph row
4339 area. X is the current output position assigned to the new glyph
4340 string constructed. HL overrides that face of the glyph; e.g. it
4341 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4342 right-most x-position of the drawing area. */
4344 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4347 int c, charset, face_id; \
4350 c = (ROW)->glyphs[AREA][START].u.ch; \
4351 face_id = (ROW)->glyphs[AREA][START].face_id; \
4353 s = (struct glyph_string *) alloca (sizeof *s); \
4354 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4355 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4356 x_append_glyph_string (&HEAD, &TAIL, s); \
4358 START = x_fill_glyph_string (s, face_id, START, END, \
4364 /* Add a glyph string for a composite sequence to the list of strings
4365 between HEAD and TAIL. START is the index of the first glyph in
4366 row area AREA of glyph row ROW that is part of the new glyph
4367 string. END is the index of the last glyph in that glyph row area.
4368 X is the current output position assigned to the new glyph string
4369 constructed. HL overrides that face of the glyph; e.g. it is
4370 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4371 x-position of the drawing area. */
4373 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4375 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4376 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4377 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4378 struct composition *cmp = composition_table[cmp_id]; \
4379 int glyph_len = cmp->glyph_len; \
4381 struct face **faces; \
4382 struct glyph_string *first_s = NULL; \
4385 base_face = base_face->ascii_face; \
4386 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4387 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4388 /* At first, fill in `char2b' and `faces'. */ \
4389 for (n = 0; n < glyph_len; n++) \
4391 int c = COMPOSITION_GLYPH (cmp, n); \
4392 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4393 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4394 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4395 this_face_id, char2b + n, 1); \
4398 /* Make glyph_strings for each glyph sequence that is drawable by \
4399 the same face, and append them to HEAD/TAIL. */ \
4400 for (n = 0; n < cmp->glyph_len;) \
4402 s = (struct glyph_string *) alloca (sizeof *s); \
4403 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
4404 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4412 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4420 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4421 of AREA of glyph row ROW on window W between indices START and END.
4422 HL overrides the face for drawing glyph strings, e.g. it is
4423 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4424 x-positions of the drawing area.
4426 This is an ugly monster macro construct because we must use alloca
4427 to allocate glyph strings (because x_draw_glyphs can be called
4430 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4433 HEAD = TAIL = NULL; \
4434 while (START < END) \
4436 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4437 switch (first_glyph->type) \
4440 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
4441 TAIL, HL, X, LAST_X, \
4445 case COMPOSITE_GLYPH: \
4446 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
4447 HEAD, TAIL, HL, X, LAST_X,\
4451 case STRETCH_GLYPH: \
4452 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
4453 HEAD, TAIL, HL, X, LAST_X); \
4457 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
4458 TAIL, HL, X, LAST_X); \
4465 x_set_glyph_string_background_width (s, START, LAST_X); \
4472 /* Draw glyphs between START and END in AREA of ROW on window W,
4473 starting at x-position X. X is relative to AREA in W. HL is a
4474 face-override with the following meaning:
4476 DRAW_NORMAL_TEXT draw normally
4477 DRAW_CURSOR draw in cursor face
4478 DRAW_MOUSE_FACE draw in mouse face.
4479 DRAW_INVERSE_VIDEO draw in mode line face
4480 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
4481 DRAW_IMAGE_RAISED draw an image with a raised relief around it
4483 If REAL_START is non-null, return in *REAL_START the real starting
4484 position for display. This can be different from START in case
4485 overlapping glyphs must be displayed. If REAL_END is non-null,
4486 return in *REAL_END the real end position for display. This can be
4487 different from END in case overlapping glyphs must be displayed.
4489 If OVERLAPS_P is non-zero, draw only the foreground of characters
4490 and clip to the physical height of ROW.
4492 Value is the x-position reached, relative to AREA of W. */
4495 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, real_start
, real_end
,
4499 struct glyph_row
*row
;
4500 enum glyph_row_area area
;
4502 enum draw_glyphs_face hl
;
4503 int *real_start
, *real_end
;
4506 struct glyph_string
*head
, *tail
;
4507 struct glyph_string
*s
;
4508 int last_x
, area_width
;
4512 /* Let's rather be paranoid than getting a SEGV. */
4513 start
= max (0, start
);
4514 end
= min (end
, row
->used
[area
]);
4516 *real_start
= start
;
4520 /* Translate X to frame coordinates. Set last_x to the right
4521 end of the drawing area. */
4522 if (row
->full_width_p
)
4524 /* X is relative to the left edge of W, without scroll bars
4526 struct frame
*f
= XFRAME (w
->frame
);
4527 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
4528 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
4531 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4532 last_x
= window_left_x
+ area_width
;
4534 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4536 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4537 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4543 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
4544 last_x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
4548 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
4549 area_width
= window_box_width (w
, area
);
4550 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
4553 /* Build a doubly-linked list of glyph_string structures between
4554 head and tail from what we have to draw. Note that the macro
4555 BUILD_GLYPH_STRINGS will modify its start parameter. That's
4556 the reason we use a separate variable `i'. */
4558 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
4561 x_reached
= tail
->x
+ tail
->background_width
;
4565 /* If there are any glyphs with lbearing < 0 or rbearing > width in
4566 the row, redraw some glyphs in front or following the glyph
4567 strings built above. */
4568 if (!overlaps_p
&& row
->contains_overlapping_glyphs_p
)
4571 struct glyph_string
*h
, *t
;
4573 /* Compute overhangs for all glyph strings. */
4574 for (s
= head
; s
; s
= s
->next
)
4575 x_compute_glyph_string_overhangs (s
);
4577 /* Prepend glyph strings for glyphs in front of the first glyph
4578 string that are overwritten because of the first glyph
4579 string's left overhang. The background of all strings
4580 prepended must be drawn because the first glyph string
4582 i
= x_left_overwritten (head
);
4586 BUILD_GLYPH_STRINGS (w
, row
, area
, j
, start
, h
, t
,
4587 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4591 *real_start
= start
;
4592 x_compute_overhangs_and_x (t
, head
->x
, 1);
4593 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4596 /* Prepend glyph strings for glyphs in front of the first glyph
4597 string that overwrite that glyph string because of their
4598 right overhang. For these strings, only the foreground must
4599 be drawn, because it draws over the glyph string at `head'.
4600 The background must not be drawn because this would overwrite
4601 right overhangs of preceding glyphs for which no glyph
4603 i
= x_left_overwriting (head
);
4606 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, start
, h
, t
,
4607 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4609 for (s
= h
; s
; s
= s
->next
)
4610 s
->background_filled_p
= 1;
4613 x_compute_overhangs_and_x (t
, head
->x
, 1);
4614 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4617 /* Append glyphs strings for glyphs following the last glyph
4618 string tail that are overwritten by tail. The background of
4619 these strings has to be drawn because tail's foreground draws
4621 i
= x_right_overwritten (tail
);
4624 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
4625 DRAW_NORMAL_TEXT
, x
, last_x
,
4627 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4628 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4633 /* Append glyph strings for glyphs following the last glyph
4634 string tail that overwrite tail. The foreground of such
4635 glyphs has to be drawn because it writes into the background
4636 of tail. The background must not be drawn because it could
4637 paint over the foreground of following glyphs. */
4638 i
= x_right_overwriting (tail
);
4641 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
4642 DRAW_NORMAL_TEXT
, x
, last_x
,
4644 for (s
= h
; s
; s
= s
->next
)
4645 s
->background_filled_p
= 1;
4646 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4647 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4653 /* Draw all strings. */
4654 for (s
= head
; s
; s
= s
->next
)
4655 x_draw_glyph_string (s
);
4657 /* Value is the x-position up to which drawn, relative to AREA of W.
4658 This doesn't include parts drawn because of overhangs. */
4659 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
4660 if (!row
->full_width_p
)
4662 if (area
> LEFT_MARGIN_AREA
)
4663 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
4664 if (area
> TEXT_AREA
)
4665 x_reached
-= window_box_width (w
, TEXT_AREA
);
4671 /* Fix the display of area AREA of overlapping row ROW in window W. */
4674 x_fix_overlapping_area (w
, row
, area
)
4676 struct glyph_row
*row
;
4677 enum glyph_row_area area
;
4683 if (area
== LEFT_MARGIN_AREA
)
4685 else if (area
== TEXT_AREA
)
4686 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
4688 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
4689 + window_box_width (w
, TEXT_AREA
));
4691 for (i
= 0; i
< row
->used
[area
];)
4693 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
4695 int start
= i
, start_x
= x
;
4699 x
+= row
->glyphs
[area
][i
].pixel_width
;
4702 while (i
< row
->used
[area
]
4703 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
4705 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
4707 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
4712 x
+= row
->glyphs
[area
][i
].pixel_width
;
4721 /* Output LEN glyphs starting at START at the nominal cursor position.
4722 Advance the nominal cursor over the text. The global variable
4723 updated_window contains the window being updated, updated_row is
4724 the glyph row being updated, and updated_area is the area of that
4725 row being updated. */
4728 x_write_glyphs (start
, len
)
4729 struct glyph
*start
;
4732 int x
, hpos
, real_start
, real_end
;
4734 xassert (updated_window
&& updated_row
);
4739 hpos
= start
- updated_row
->glyphs
[updated_area
];
4740 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
4741 updated_row
, updated_area
,
4743 (updated_row
->inverse_p
4744 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
4745 &real_start
, &real_end
, 0);
4747 /* If we drew over the cursor, note that it is not visible any more. */
4748 note_overwritten_text_cursor (updated_window
, real_start
,
4749 real_end
- real_start
);
4753 /* Advance the output cursor. */
4754 output_cursor
.hpos
+= len
;
4755 output_cursor
.x
= x
;
4759 /* Insert LEN glyphs from START at the nominal cursor position. */
4762 x_insert_glyphs (start
, len
)
4763 struct glyph
*start
;
4768 int line_height
, shift_by_width
, shifted_region_width
;
4769 struct glyph_row
*row
;
4770 struct glyph
*glyph
;
4771 int frame_x
, frame_y
, hpos
, real_start
, real_end
;
4773 xassert (updated_window
&& updated_row
);
4776 f
= XFRAME (WINDOW_FRAME (w
));
4778 /* Get the height of the line we are in. */
4780 line_height
= row
->height
;
4782 /* Get the width of the glyphs to insert. */
4784 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
4785 shift_by_width
+= glyph
->pixel_width
;
4787 /* Get the width of the region to shift right. */
4788 shifted_region_width
= (window_box_width (w
, updated_area
)
4793 frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, output_cursor
.x
);
4794 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
4795 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
4796 f
->output_data
.x
->normal_gc
,
4798 shifted_region_width
, line_height
,
4799 frame_x
+ shift_by_width
, frame_y
);
4801 /* Write the glyphs. */
4802 hpos
= start
- row
->glyphs
[updated_area
];
4803 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
4804 DRAW_NORMAL_TEXT
, &real_start
, &real_end
, 0);
4805 note_overwritten_text_cursor (w
, real_start
, real_end
- real_start
);
4807 /* Advance the output cursor. */
4808 output_cursor
.hpos
+= len
;
4809 output_cursor
.x
+= shift_by_width
;
4814 /* Delete N glyphs at the nominal cursor position. Not implemented
4825 /* Erase the current text line from the nominal cursor position
4826 (inclusive) to pixel column TO_X (exclusive). The idea is that
4827 everything from TO_X onward is already erased.
4829 TO_X is a pixel position relative to updated_area of
4830 updated_window. TO_X == -1 means clear to the end of this area. */
4833 x_clear_end_of_line (to_x
)
4837 struct window
*w
= updated_window
;
4838 int max_x
, min_y
, max_y
;
4839 int from_x
, from_y
, to_y
;
4841 xassert (updated_window
&& updated_row
);
4842 f
= XFRAME (w
->frame
);
4844 if (updated_row
->full_width_p
)
4846 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4847 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4848 && !w
->pseudo_window_p
)
4849 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4852 max_x
= window_box_width (w
, updated_area
);
4853 max_y
= window_text_bottom_y (w
);
4855 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
4856 of window. For TO_X > 0, truncate to end of drawing area. */
4862 to_x
= min (to_x
, max_x
);
4864 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
4866 /* Notice if the cursor will be cleared by this operation. */
4867 if (!updated_row
->full_width_p
)
4868 note_overwritten_text_cursor (w
, output_cursor
.hpos
, -1);
4870 from_x
= output_cursor
.x
;
4872 /* Translate to frame coordinates. */
4873 if (updated_row
->full_width_p
)
4875 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
4876 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
4880 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
4881 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
4884 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
4885 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
4886 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
4888 /* Prevent inadvertently clearing to end of the X window. */
4889 if (to_x
> from_x
&& to_y
> from_y
)
4892 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4893 from_x
, from_y
, to_x
- from_x
, to_y
- from_y
,
4900 /* Clear entire frame. If updating_frame is non-null, clear that
4901 frame. Otherwise clear the selected frame. */
4911 f
= SELECTED_FRAME ();
4913 /* Clearing the frame will erase any cursor, so mark them all as no
4915 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
4916 output_cursor
.hpos
= output_cursor
.vpos
= 0;
4917 output_cursor
.x
= -1;
4919 /* We don't set the output cursor here because there will always
4920 follow an explicit cursor_to. */
4922 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
4924 /* We have to clear the scroll bars, too. If we have changed
4925 colors or something like that, then they should be notified. */
4926 x_scroll_bar_clear (f
);
4928 XFlush (FRAME_X_DISPLAY (f
));
4934 /* Invert the middle quarter of the frame for .15 sec. */
4936 /* We use the select system call to do the waiting, so we have to make
4937 sure it's available. If it isn't, we just won't do visual bells. */
4939 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
4942 /* Subtract the `struct timeval' values X and Y, storing the result in
4943 *RESULT. Return 1 if the difference is negative, otherwise 0. */
4946 timeval_subtract (result
, x
, y
)
4947 struct timeval
*result
, x
, y
;
4949 /* Perform the carry for the later subtraction by updating y. This
4950 is safer because on some systems the tv_sec member is unsigned. */
4951 if (x
.tv_usec
< y
.tv_usec
)
4953 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
4954 y
.tv_usec
-= 1000000 * nsec
;
4958 if (x
.tv_usec
- y
.tv_usec
> 1000000)
4960 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
4961 y
.tv_usec
+= 1000000 * nsec
;
4965 /* Compute the time remaining to wait. tv_usec is certainly
4967 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
4968 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
4970 /* Return indication of whether the result should be considered
4972 return x
.tv_sec
< y
.tv_sec
;
4984 /* Create a GC that will use the GXxor function to flip foreground
4985 pixels into background pixels. */
4989 values
.function
= GXxor
;
4990 values
.foreground
= (f
->output_data
.x
->foreground_pixel
4991 ^ f
->output_data
.x
->background_pixel
);
4993 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4994 GCFunction
| GCForeground
, &values
);
4998 /* Get the height not including a menu bar widget. */
4999 int height
= CHAR_TO_PIXEL_HEIGHT (f
, FRAME_HEIGHT (f
));
5000 /* Height of each line to flash. */
5001 int flash_height
= FRAME_LINE_HEIGHT (f
);
5002 /* These will be the left and right margins of the rectangles. */
5003 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
5004 int flash_right
= PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
5008 /* Don't flash the area between a scroll bar and the frame
5009 edge it is next to. */
5010 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
5012 case vertical_scroll_bar_left
:
5013 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5016 case vertical_scroll_bar_right
:
5017 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5024 width
= flash_right
- flash_left
;
5026 /* If window is tall, flash top and bottom line. */
5027 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5029 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5031 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5032 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5033 width
, flash_height
);
5034 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5036 (height
- flash_height
5037 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5038 width
, flash_height
);
5041 /* If it is short, flash it all. */
5042 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5043 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5044 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5049 struct timeval wakeup
;
5051 EMACS_GET_TIME (wakeup
);
5053 /* Compute time to wait until, propagating carry from usecs. */
5054 wakeup
.tv_usec
+= 150000;
5055 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
5056 wakeup
.tv_usec
%= 1000000;
5058 /* Keep waiting until past the time wakeup. */
5061 struct timeval timeout
;
5063 EMACS_GET_TIME (timeout
);
5065 /* In effect, timeout = wakeup - timeout.
5066 Break if result would be negative. */
5067 if (timeval_subtract (&timeout
, wakeup
, timeout
))
5070 /* Try to wait that long--but we might wake up sooner. */
5071 select (0, NULL
, NULL
, NULL
, &timeout
);
5075 /* If window is tall, flash top and bottom line. */
5076 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
5078 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5080 (FRAME_INTERNAL_BORDER_WIDTH (f
)
5081 + FRAME_TOOL_BAR_LINES (f
) * CANON_Y_UNIT (f
)),
5082 width
, flash_height
);
5083 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5085 (height
- flash_height
5086 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
5087 width
, flash_height
);
5090 /* If it is short, flash it all. */
5091 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
5092 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
5093 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
5095 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5103 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5106 /* Make audible bell. */
5111 struct frame
*f
= SELECTED_FRAME ();
5113 if (FRAME_X_DISPLAY (f
))
5115 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5122 XBell (FRAME_X_DISPLAY (f
), 0);
5123 XFlush (FRAME_X_DISPLAY (f
));
5130 /* Specify how many text lines, from the top of the window,
5131 should be affected by insert-lines and delete-lines operations.
5132 This, and those operations, are used only within an update
5133 that is bounded by calls to x_update_begin and x_update_end. */
5136 XTset_terminal_window (n
)
5139 /* This function intentionally left blank. */
5144 /***********************************************************************
5146 ***********************************************************************/
5148 /* Perform an insert-lines or delete-lines operation, inserting N
5149 lines or deleting -N lines at vertical position VPOS. */
5152 x_ins_del_lines (vpos
, n
)
5159 /* Scroll part of the display as described by RUN. */
5162 x_scroll_run (w
, run
)
5166 struct frame
*f
= XFRAME (w
->frame
);
5167 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5169 /* Get frame-relative bounding box of the text display area of W,
5170 without mode lines. Include in this box the flags areas to the
5171 left and right of W. */
5172 window_box (w
, -1, &x
, &y
, &width
, &height
);
5173 width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
5174 x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
5176 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5177 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5178 bottom_y
= y
+ height
;
5182 /* Scrolling up. Make sure we don't copy part of the mode
5183 line at the bottom. */
5184 if (from_y
+ run
->height
> bottom_y
)
5185 height
= bottom_y
- from_y
;
5187 height
= run
->height
;
5191 /* Scolling down. Make sure we don't copy over the mode line.
5193 if (to_y
+ run
->height
> bottom_y
)
5194 height
= bottom_y
- to_y
;
5196 height
= run
->height
;
5201 /* Cursor off. Will be switched on again in x_update_window_end. */
5205 XCopyArea (FRAME_X_DISPLAY (f
),
5206 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
5207 f
->output_data
.x
->normal_gc
,
5217 /***********************************************************************
5219 ***********************************************************************/
5221 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5222 corner of the exposed rectangle. W and H are width and height of
5223 the exposed area. All are pixel values. W or H zero means redraw
5224 the entire frame. */
5227 expose_frame (f
, x
, y
, w
, h
)
5233 TRACE ((stderr
, "expose_frame "));
5235 /* No need to redraw if frame will be redrawn soon. */
5236 if (FRAME_GARBAGED_P (f
))
5238 TRACE ((stderr
, " garbaged\n"));
5242 /* If basic faces haven't been realized yet, there is no point in
5243 trying to redraw anything. This can happen when we get an expose
5244 event while Emacs is starting, e.g. by moving another window. */
5245 if (FRAME_FACE_CACHE (f
) == NULL
5246 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5248 TRACE ((stderr
, " no faces\n"));
5252 if (w
== 0 || h
== 0)
5255 r
.width
= CANON_X_UNIT (f
) * f
->width
;
5256 r
.height
= CANON_Y_UNIT (f
) * f
->height
;
5266 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
5267 expose_window_tree (XWINDOW (f
->root_window
), &r
);
5269 if (WINDOWP (f
->tool_bar_window
))
5271 struct window
*w
= XWINDOW (f
->tool_bar_window
);
5272 XRectangle window_rect
;
5273 XRectangle intersection_rect
;
5274 int window_x
, window_y
, window_width
, window_height
;
5277 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5278 window_rect
.x
= window_x
;
5279 window_rect
.y
= window_y
;
5280 window_rect
.width
= window_width
;
5281 window_rect
.height
= window_height
;
5283 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5284 expose_window (w
, &intersection_rect
);
5287 #ifndef USE_X_TOOLKIT
5288 if (WINDOWP (f
->menu_bar_window
))
5290 struct window
*w
= XWINDOW (f
->menu_bar_window
);
5291 XRectangle window_rect
;
5292 XRectangle intersection_rect
;
5293 int window_x
, window_y
, window_width
, window_height
;
5296 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5297 window_rect
.x
= window_x
;
5298 window_rect
.y
= window_y
;
5299 window_rect
.width
= window_width
;
5300 window_rect
.height
= window_height
;
5302 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5303 expose_window (w
, &intersection_rect
);
5305 #endif /* not USE_X_TOOLKIT */
5309 /* Redraw (parts) of all windows in the window tree rooted at W that
5310 intersect R. R contains frame pixel coordinates. */
5313 expose_window_tree (w
, r
)
5319 if (!NILP (w
->hchild
))
5320 expose_window_tree (XWINDOW (w
->hchild
), r
);
5321 else if (!NILP (w
->vchild
))
5322 expose_window_tree (XWINDOW (w
->vchild
), r
);
5325 XRectangle window_rect
;
5326 XRectangle intersection_rect
;
5327 struct frame
*f
= XFRAME (w
->frame
);
5328 int window_x
, window_y
, window_width
, window_height
;
5330 /* Frame-relative pixel rectangle of W. */
5331 window_box (w
, -1, &window_x
, &window_y
, &window_width
,
5335 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
5336 - FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5337 window_rect
.y
= window_y
;
5340 + FRAME_X_FLAGS_AREA_WIDTH (f
)
5341 + FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5343 = window_height
+ CURRENT_MODE_LINE_HEIGHT (w
);
5345 if (x_intersect_rectangles (r
, &window_rect
, &intersection_rect
))
5346 expose_window (w
, &intersection_rect
);
5349 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5354 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5355 which intersects rectangle R. R is in window-relative coordinates. */
5358 expose_area (w
, row
, r
, area
)
5360 struct glyph_row
*row
;
5362 enum glyph_row_area area
;
5365 struct glyph
*first
= row
->glyphs
[area
];
5366 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5370 /* Set x to the window-relative start position for drawing glyphs of
5371 AREA. The first glyph of the text area can be partially visible.
5372 The first glyphs of other areas cannot. */
5373 if (area
== LEFT_MARGIN_AREA
)
5375 else if (area
== TEXT_AREA
)
5376 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5378 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5379 + window_box_width (w
, TEXT_AREA
));
5381 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5382 /* If row extends face to end of line write the whole line. */
5383 x_draw_glyphs (w
, x
, row
, area
,
5385 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5389 /* Find the first glyph that must be redrawn. */
5391 && x
+ first
->pixel_width
< r
->x
)
5393 x
+= first
->pixel_width
;
5397 /* Find the last one. */
5401 && x
< r
->x
+ r
->width
)
5403 x
+= last
->pixel_width
;
5409 x_draw_glyphs (w
, first_x
, row
, area
,
5410 first
- row
->glyphs
[area
],
5411 last
- row
->glyphs
[area
],
5412 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5418 /* Redraw the parts of the glyph row ROW on window W intersecting
5419 rectangle R. R is in window-relative coordinates. */
5422 expose_line (w
, row
, r
)
5424 struct glyph_row
*row
;
5427 xassert (row
->enabled_p
);
5429 if (row
->mode_line_p
|| w
->pseudo_window_p
)
5430 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
5431 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5435 if (row
->used
[LEFT_MARGIN_AREA
])
5436 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
5437 if (row
->used
[TEXT_AREA
])
5438 expose_area (w
, row
, r
, TEXT_AREA
);
5439 if (row
->used
[RIGHT_MARGIN_AREA
])
5440 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
5441 x_draw_row_bitmaps (w
, row
);
5446 /* Return non-zero if W's cursor intersects rectangle R. */
5449 x_phys_cursor_in_rect_p (w
, r
)
5453 XRectangle cr
, result
;
5454 struct glyph
*cursor_glyph
;
5456 cursor_glyph
= get_phys_cursor_glyph (w
);
5459 cr
.x
= w
->phys_cursor
.x
;
5460 cr
.y
= w
->phys_cursor
.y
;
5461 cr
.width
= cursor_glyph
->pixel_width
;
5462 cr
.height
= w
->phys_cursor_height
;
5463 return x_intersect_rectangles (&cr
, r
, &result
);
5470 /* Redraw a rectangle of window W. R is a rectangle in window
5471 relative coordinates. Call this function with input blocked. */
5474 expose_window (w
, r
)
5478 struct glyph_row
*row
;
5480 int yb
= window_text_bottom_y (w
);
5481 int cursor_cleared_p
;
5483 /* If window is not yet fully initialized, do nothing. This can
5484 happen when toolkit scroll bars are used and a window is split.
5485 Reconfiguring the scroll bar will generate an expose for a newly
5487 if (w
->current_matrix
== NULL
)
5490 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
5491 r
->x
, r
->y
, r
->width
, r
->height
));
5493 /* Convert to window coordinates. */
5494 r
->x
= FRAME_TO_WINDOW_PIXEL_X (w
, r
->x
);
5495 r
->y
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
->y
);
5497 /* Turn off the cursor. */
5498 if (!w
->pseudo_window_p
5499 && x_phys_cursor_in_rect_p (w
, r
))
5502 cursor_cleared_p
= 1;
5505 cursor_cleared_p
= 0;
5507 /* Find the first row intersecting the rectangle R. */
5508 row
= w
->current_matrix
->rows
;
5510 while (row
->enabled_p
5512 && y
+ row
->height
< r
->y
)
5518 /* Display the text in the rectangle, one text line at a time. */
5519 while (row
->enabled_p
5521 && y
< r
->y
+ r
->height
)
5523 expose_line (w
, row
, r
);
5528 /* Display the mode line if there is one. */
5529 if (WINDOW_WANTS_MODELINE_P (w
)
5530 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
5532 && row
->y
< r
->y
+ r
->height
)
5533 expose_line (w
, row
, r
);
5535 if (!w
->pseudo_window_p
)
5537 /* Draw border between windows. */
5538 x_draw_vertical_border (w
);
5540 /* Turn the cursor on again. */
5541 if (cursor_cleared_p
)
5542 x_update_window_cursor (w
, 1);
5547 /* Determine the intersection of two rectangles R1 and R2. Return
5548 the intersection in *RESULT. Value is non-zero if RESULT is not
5552 x_intersect_rectangles (r1
, r2
, result
)
5553 XRectangle
*r1
, *r2
, *result
;
5555 XRectangle
*left
, *right
;
5556 XRectangle
*upper
, *lower
;
5557 int intersection_p
= 0;
5559 /* Rearrange so that R1 is the left-most rectangle. */
5561 left
= r1
, right
= r2
;
5563 left
= r2
, right
= r1
;
5565 /* X0 of the intersection is right.x0, if this is inside R1,
5566 otherwise there is no intersection. */
5567 if (right
->x
<= left
->x
+ left
->width
)
5569 result
->x
= right
->x
;
5571 /* The right end of the intersection is the minimum of the
5572 the right ends of left and right. */
5573 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
5576 /* Same game for Y. */
5578 upper
= r1
, lower
= r2
;
5580 upper
= r2
, lower
= r1
;
5582 /* The upper end of the intersection is lower.y0, if this is inside
5583 of upper. Otherwise, there is no intersection. */
5584 if (lower
->y
<= upper
->y
+ upper
->height
)
5586 result
->y
= lower
->y
;
5588 /* The lower end of the intersection is the minimum of the lower
5589 ends of upper and lower. */
5590 result
->height
= (min (lower
->y
+ lower
->height
,
5591 upper
->y
+ upper
->height
)
5597 return intersection_p
;
5608 /* We used to only do this if Vx_no_window_manager was non-nil, but
5609 the ICCCM (section 4.1.6) says that the window's border pixmap
5610 and border pixel are window attributes which are "private to the
5611 client", so we can always change it to whatever we want. */
5613 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5614 f
->output_data
.x
->border_pixel
);
5616 x_update_cursor (f
, 1);
5620 frame_unhighlight (f
)
5623 /* We used to only do this if Vx_no_window_manager was non-nil, but
5624 the ICCCM (section 4.1.6) says that the window's border pixmap
5625 and border pixel are window attributes which are "private to the
5626 client", so we can always change it to whatever we want. */
5628 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5629 f
->output_data
.x
->border_tile
);
5631 x_update_cursor (f
, 1);
5634 /* The focus has changed. Update the frames as necessary to reflect
5635 the new situation. Note that we can't change the selected frame
5636 here, because the Lisp code we are interrupting might become confused.
5637 Each event gets marked with the frame in which it occurred, so the
5638 Lisp code can tell when the switch took place by examining the events. */
5641 x_new_focus_frame (dpyinfo
, frame
)
5642 struct x_display_info
*dpyinfo
;
5643 struct frame
*frame
;
5645 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
5647 if (frame
!= dpyinfo
->x_focus_frame
)
5649 /* Set this before calling other routines, so that they see
5650 the correct value of x_focus_frame. */
5651 dpyinfo
->x_focus_frame
= frame
;
5653 if (old_focus
&& old_focus
->auto_lower
)
5654 x_lower_frame (old_focus
);
5657 selected_frame
= frame
;
5658 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
5660 Fselect_window (selected_frame
->selected_window
);
5661 choose_minibuf_frame ();
5664 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
5665 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
5667 pending_autoraise_frame
= 0;
5670 x_frame_rehighlight (dpyinfo
);
5673 /* Handle an event saying the mouse has moved out of an Emacs frame. */
5676 x_mouse_leave (dpyinfo
)
5677 struct x_display_info
*dpyinfo
;
5679 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
5682 /* The focus has changed, or we have redirected a frame's focus to
5683 another frame (this happens when a frame uses a surrogate
5684 mini-buffer frame). Shift the highlight as appropriate.
5686 The FRAME argument doesn't necessarily have anything to do with which
5687 frame is being highlighted or un-highlighted; we only use it to find
5688 the appropriate X display info. */
5691 XTframe_rehighlight (frame
)
5692 struct frame
*frame
;
5694 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
5698 x_frame_rehighlight (dpyinfo
)
5699 struct x_display_info
*dpyinfo
;
5701 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
5703 if (dpyinfo
->x_focus_frame
)
5705 dpyinfo
->x_highlight_frame
5706 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
5707 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
5708 : dpyinfo
->x_focus_frame
);
5709 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
5711 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
5712 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
5716 dpyinfo
->x_highlight_frame
= 0;
5718 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
5721 frame_unhighlight (old_highlight
);
5722 if (dpyinfo
->x_highlight_frame
)
5723 frame_highlight (dpyinfo
->x_highlight_frame
);
5729 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
5731 /* Initialize mode_switch_bit and modifier_meaning. */
5733 x_find_modifier_meanings (dpyinfo
)
5734 struct x_display_info
*dpyinfo
;
5736 int min_code
, max_code
;
5739 XModifierKeymap
*mods
;
5741 dpyinfo
->meta_mod_mask
= 0;
5742 dpyinfo
->shift_lock_mask
= 0;
5743 dpyinfo
->alt_mod_mask
= 0;
5744 dpyinfo
->super_mod_mask
= 0;
5745 dpyinfo
->hyper_mod_mask
= 0;
5748 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
5750 min_code
= dpyinfo
->display
->min_keycode
;
5751 max_code
= dpyinfo
->display
->max_keycode
;
5754 syms
= XGetKeyboardMapping (dpyinfo
->display
,
5755 min_code
, max_code
- min_code
+ 1,
5757 mods
= XGetModifierMapping (dpyinfo
->display
);
5759 /* Scan the modifier table to see which modifier bits the Meta and
5760 Alt keysyms are on. */
5762 int row
, col
; /* The row and column in the modifier table. */
5764 for (row
= 3; row
< 8; row
++)
5765 for (col
= 0; col
< mods
->max_keypermod
; col
++)
5768 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
5770 /* Zeroes are used for filler. Skip them. */
5774 /* Are any of this keycode's keysyms a meta key? */
5778 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
5780 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
5786 dpyinfo
->meta_mod_mask
|= (1 << row
);
5791 dpyinfo
->alt_mod_mask
|= (1 << row
);
5796 dpyinfo
->hyper_mod_mask
|= (1 << row
);
5801 dpyinfo
->super_mod_mask
|= (1 << row
);
5805 /* Ignore this if it's not on the lock modifier. */
5806 if ((1 << row
) == LockMask
)
5807 dpyinfo
->shift_lock_mask
= LockMask
;
5815 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
5816 if (! dpyinfo
->meta_mod_mask
)
5818 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
5819 dpyinfo
->alt_mod_mask
= 0;
5822 /* If some keys are both alt and meta,
5823 make them just meta, not alt. */
5824 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
5826 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
5829 XFree ((char *) syms
);
5830 XFreeModifiermap (mods
);
5833 /* Convert between the modifier bits X uses and the modifier bits
5837 x_x_to_emacs_modifiers (dpyinfo
, state
)
5838 struct x_display_info
*dpyinfo
;
5841 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
5842 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
5843 | ((state
& dpyinfo
->meta_mod_mask
) ? meta_modifier
: 0)
5844 | ((state
& dpyinfo
->alt_mod_mask
) ? alt_modifier
: 0)
5845 | ((state
& dpyinfo
->super_mod_mask
) ? super_modifier
: 0)
5846 | ((state
& dpyinfo
->hyper_mod_mask
) ? hyper_modifier
: 0));
5850 x_emacs_to_x_modifiers (dpyinfo
, state
)
5851 struct x_display_info
*dpyinfo
;
5854 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
5855 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
5856 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
5857 | ((state
& shift_modifier
) ? ShiftMask
: 0)
5858 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
5859 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
5862 /* Convert a keysym to its name. */
5865 x_get_keysym_name (keysym
)
5871 value
= XKeysymToString (keysym
);
5879 /* Mouse clicks and mouse movement. Rah. */
5881 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
5882 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
5883 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
5884 not force the value into range. */
5887 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
5889 register int pix_x
, pix_y
;
5890 register int *x
, *y
;
5894 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
5895 even for negative values. */
5897 pix_x
-= FONT_WIDTH ((f
)->output_data
.x
->font
) - 1;
5899 pix_y
-= (f
)->output_data
.x
->line_height
- 1;
5901 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
5902 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
5906 bounds
->width
= FONT_WIDTH (f
->output_data
.x
->font
);
5907 bounds
->height
= f
->output_data
.x
->line_height
;
5908 bounds
->x
= CHAR_TO_PIXEL_COL (f
, pix_x
);
5909 bounds
->y
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
5916 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
5917 pix_x
= FRAME_WINDOW_WIDTH (f
);
5921 else if (pix_y
> f
->height
)
5930 /* Given HPOS/VPOS in the current matrix of W, return corresponding
5931 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
5932 can't tell the positions because W's display is not up to date,
5936 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
5939 int *frame_x
, *frame_y
;
5943 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
5944 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
5946 if (display_completed
)
5948 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
5949 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
5950 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
5956 *frame_x
+= glyph
->pixel_width
;
5964 *frame_y
= *frame_x
= 0;
5968 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
5969 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
5974 /* Prepare a mouse-event in *RESULT for placement in the input queue.
5976 If the event is a button press, then note that we have grabbed
5980 construct_mouse_click (result
, event
, f
)
5981 struct input_event
*result
;
5982 XButtonEvent
*event
;
5985 /* Make the event type no_event; we'll change that when we decide
5987 result
->kind
= mouse_click
;
5988 result
->code
= event
->button
- Button1
;
5989 result
->timestamp
= event
->time
;
5990 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
5992 | (event
->type
== ButtonRelease
5996 XSETINT (result
->x
, event
->x
);
5997 XSETINT (result
->y
, event
->y
);
5998 XSETFRAME (result
->frame_or_window
, f
);
6002 #if 0 /* This function isn't called. --gerd */
6004 /* Prepare a menu-event in *RESULT for placement in the input queue. */
6007 construct_menu_click (result
, event
, f
)
6008 struct input_event
*result
;
6009 XButtonEvent
*event
;
6012 /* Make the event type no_event; we'll change that when we decide
6014 result
->kind
= mouse_click
;
6015 result
->code
= event
->button
- Button1
;
6016 result
->timestamp
= event
->time
;
6017 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6019 | (event
->type
== ButtonRelease
6023 XSETINT (result
->x
, event
->x
);
6024 XSETINT (result
->y
, -1);
6025 XSETFRAME (result
->frame_or_window
, f
);
6031 /* Function to report a mouse movement to the mainstream Emacs code.
6032 The input handler calls this.
6034 We have received a mouse movement event, which is given in *event.
6035 If the mouse is over a different glyph than it was last time, tell
6036 the mainstream emacs code by setting mouse_moved. If not, ask for
6037 another motion event, so we can check again the next time it moves. */
6039 static XMotionEvent last_mouse_motion_event
;
6040 static Lisp_Object last_mouse_motion_frame
;
6043 note_mouse_movement (frame
, event
)
6045 XMotionEvent
*event
;
6047 last_mouse_movement_time
= event
->time
;
6048 last_mouse_motion_event
= *event
;
6049 XSETFRAME (last_mouse_motion_frame
, frame
);
6051 if (event
->window
!= FRAME_X_WINDOW (frame
))
6053 frame
->mouse_moved
= 1;
6054 last_mouse_scroll_bar
= Qnil
;
6055 note_mouse_highlight (frame
, -1, -1);
6058 /* Has the mouse moved off the glyph it was on at the last sighting? */
6059 else if (event
->x
< last_mouse_glyph
.x
6060 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
6061 || event
->y
< last_mouse_glyph
.y
6062 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
6064 frame
->mouse_moved
= 1;
6065 last_mouse_scroll_bar
= Qnil
;
6066 note_mouse_highlight (frame
, event
->x
, event
->y
);
6070 /* This is used for debugging, to turn off note_mouse_highlight. */
6072 int disable_mouse_highlight
;
6076 /************************************************************************
6078 ************************************************************************/
6080 /* Find the glyph under window-relative coordinates X/Y in window W.
6081 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6082 strings. Return in *HPOS and *VPOS the row and column number of
6083 the glyph found. Return in *AREA the glyph area containing X.
6084 Value is a pointer to the glyph found or null if X/Y is not on
6085 text, or we can't tell because W's current matrix is not up to
6088 static struct glyph
*
6089 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
)
6092 int *hpos
, *vpos
, *area
;
6094 struct glyph
*glyph
, *end
;
6095 struct glyph_row
*row
;
6096 int x0
, i
, left_area_width
;
6098 /* Find row containing Y. Give up if some row is not enabled. */
6099 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6101 row
= MATRIX_ROW (w
->current_matrix
, i
);
6102 if (!row
->enabled_p
)
6104 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6111 /* Give up if Y is not in the window. */
6112 if (i
== w
->current_matrix
->nrows
)
6115 /* Get the glyph area containing X. */
6116 if (w
->pseudo_window_p
)
6123 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6124 if (x
< left_area_width
)
6126 *area
= LEFT_MARGIN_AREA
;
6129 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6132 x0
= row
->x
+ left_area_width
;
6136 *area
= RIGHT_MARGIN_AREA
;
6137 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6141 /* Find glyph containing X. */
6142 glyph
= row
->glyphs
[*area
];
6143 end
= glyph
+ row
->used
[*area
];
6146 if (x
< x0
+ glyph
->pixel_width
)
6148 if (w
->pseudo_window_p
)
6150 else if (BUFFERP (glyph
->object
))
6154 x0
+= glyph
->pixel_width
;
6161 *hpos
= glyph
- row
->glyphs
[*area
];
6166 /* Convert frame-relative x/y to coordinates relative to window W.
6167 Takes pseudo-windows into account. */
6170 frame_to_window_pixel_xy (w
, x
, y
)
6174 if (w
->pseudo_window_p
)
6176 /* A pseudo-window is always full-width, and starts at the
6177 left edge of the frame, plus a frame border. */
6178 struct frame
*f
= XFRAME (w
->frame
);
6179 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6180 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6184 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6185 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6190 /* Take proper action when mouse has moved to the mode or top line of
6191 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6192 mode line. X is relative to the start of the text display area of
6193 W, so the width of bitmap areas and scroll bars must be subtracted
6194 to get a position relative to the start of the mode line. */
6197 note_mode_line_highlight (w
, x
, mode_line_p
)
6201 struct frame
*f
= XFRAME (w
->frame
);
6202 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6203 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6204 struct glyph_row
*row
;
6207 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6209 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6213 struct glyph
*glyph
, *end
;
6214 Lisp_Object help
, map
;
6217 /* Find the glyph under X. */
6218 glyph
= row
->glyphs
[TEXT_AREA
];
6219 end
= glyph
+ row
->used
[TEXT_AREA
];
6220 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6221 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
));
6223 && x
>= x0
+ glyph
->pixel_width
)
6225 x0
+= glyph
->pixel_width
;
6230 && STRINGP (glyph
->object
)
6231 && XSTRING (glyph
->object
)->intervals
6232 && glyph
->charpos
>= 0
6233 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6235 /* If we're on a string with `help-echo' text property,
6236 arrange for the help to be displayed. This is done by
6237 setting the global variable help_echo to the help string. */
6238 help
= Fget_text_property (make_number (glyph
->charpos
),
6239 Qhelp_echo
, glyph
->object
);
6243 /* Change the mouse pointer according to what is under X/Y. */
6244 map
= Fget_text_property (make_number (glyph
->charpos
),
6245 Qlocal_map
, glyph
->object
);
6246 if (!NILP (Fkeymapp (map
)))
6247 cursor
= f
->output_data
.x
->nontext_cursor
;
6251 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6255 /* Take proper action when the mouse has moved to position X, Y on
6256 frame F as regards highlighting characters that have mouse-face
6257 properties. Also de-highlighting chars where the mouse was before.
6258 X and Y can be negative or out of range. */
6261 note_mouse_highlight (f
, x
, y
)
6265 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6270 /* When a menu is active, don't highlight because this looks odd. */
6271 #ifdef USE_X_TOOLKIT
6272 if (popup_activated ())
6276 if (disable_mouse_highlight
6277 || !f
->glyphs_initialized_p
)
6280 dpyinfo
->mouse_face_mouse_x
= x
;
6281 dpyinfo
->mouse_face_mouse_y
= y
;
6282 dpyinfo
->mouse_face_mouse_frame
= f
;
6284 if (dpyinfo
->mouse_face_defer
)
6289 dpyinfo
->mouse_face_deferred_gc
= 1;
6293 /* Which window is that in? */
6294 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6296 /* If we were displaying active text in another window, clear that. */
6297 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6298 clear_mouse_face (dpyinfo
);
6300 /* Not on a window -> return. */
6301 if (!WINDOWP (window
))
6304 /* Convert to window-relative pixel coordinates. */
6305 w
= XWINDOW (window
);
6306 frame_to_window_pixel_xy (w
, &x
, &y
);
6308 /* Handle tool-bar window differently since it doesn't display a
6310 if (EQ (window
, f
->tool_bar_window
))
6312 note_tool_bar_highlight (f
, x
, y
);
6316 if (portion
== 1 || portion
== 3)
6318 /* Mouse is on the mode or top line. */
6319 note_mode_line_highlight (w
, x
, portion
== 1);
6323 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6324 f
->output_data
.x
->text_cursor
);
6326 /* Are we in a window whose display is up to date?
6327 And verify the buffer's text has not changed. */
6328 if (/* Within text portion of the window. */
6330 && EQ (w
->window_end_valid
, w
->buffer
)
6331 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
6332 && (XFASTINT (w
->last_overlay_modified
)
6333 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
6335 int hpos
, vpos
, pos
, i
, area
;
6336 struct glyph
*glyph
;
6338 /* Find the glyph under X/Y. */
6339 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
);
6341 /* Clear mouse face if X/Y not over text. */
6343 || area
!= TEXT_AREA
6344 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6346 clear_mouse_face (dpyinfo
);
6350 pos
= glyph
->charpos
;
6351 xassert (w
->pseudo_window_p
|| BUFFERP (glyph
->object
));
6353 /* Check for mouse-face and help-echo. */
6355 Lisp_Object mouse_face
, overlay
, position
;
6356 Lisp_Object
*overlay_vec
;
6358 struct buffer
*obuf
;
6361 /* If we get an out-of-range value, return now; avoid an error. */
6362 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
6365 /* Make the window's buffer temporarily current for
6366 overlays_at and compute_char_face. */
6367 obuf
= current_buffer
;
6368 current_buffer
= XBUFFER (w
->buffer
);
6374 /* Is this char mouse-active or does it have help-echo? */
6375 XSETINT (position
, pos
);
6377 /* Put all the overlays we want in a vector in overlay_vec.
6378 Store the length in len. If there are more than 10, make
6379 enough space for all, and try again. */
6381 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6382 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
6383 if (noverlays
> len
)
6386 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6387 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
6390 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6392 /* Check mouse-face highlighting. */
6393 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
6394 && vpos
>= dpyinfo
->mouse_face_beg_row
6395 && vpos
<= dpyinfo
->mouse_face_end_row
6396 && (vpos
> dpyinfo
->mouse_face_beg_row
6397 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6398 && (vpos
< dpyinfo
->mouse_face_end_row
6399 || hpos
< dpyinfo
->mouse_face_end_col
6400 || dpyinfo
->mouse_face_past_end
)))
6402 /* Clear the display of the old active region, if any. */
6403 clear_mouse_face (dpyinfo
);
6405 /* Find the highest priority overlay that has a mouse-face prop. */
6407 for (i
= 0; i
< noverlays
; i
++)
6409 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
6410 if (!NILP (mouse_face
))
6412 overlay
= overlay_vec
[i
];
6417 /* If no overlay applies, get a text property. */
6419 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
6421 /* Handle the overlay case. */
6422 if (! NILP (overlay
))
6424 /* Find the range of text around this char that
6425 should be active. */
6426 Lisp_Object before
, after
;
6429 before
= Foverlay_start (overlay
);
6430 after
= Foverlay_end (overlay
);
6431 /* Record this as the current active region. */
6432 fast_find_position (w
, XFASTINT (before
),
6433 &dpyinfo
->mouse_face_beg_col
,
6434 &dpyinfo
->mouse_face_beg_row
,
6435 &dpyinfo
->mouse_face_beg_x
,
6436 &dpyinfo
->mouse_face_beg_y
);
6437 dpyinfo
->mouse_face_past_end
6438 = !fast_find_position (w
, XFASTINT (after
),
6439 &dpyinfo
->mouse_face_end_col
,
6440 &dpyinfo
->mouse_face_end_row
,
6441 &dpyinfo
->mouse_face_end_x
,
6442 &dpyinfo
->mouse_face_end_y
);
6443 dpyinfo
->mouse_face_window
= window
;
6444 dpyinfo
->mouse_face_face_id
6445 = face_at_buffer_position (w
, pos
, 0, 0,
6446 &ignore
, pos
+ 1, 1);
6448 /* Display it as active. */
6449 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6451 /* Handle the text property case. */
6452 else if (! NILP (mouse_face
))
6454 /* Find the range of text around this char that
6455 should be active. */
6456 Lisp_Object before
, after
, beginning
, end
;
6459 beginning
= Fmarker_position (w
->start
);
6460 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
6461 - XFASTINT (w
->window_end_pos
)));
6463 = Fprevious_single_property_change (make_number (pos
+ 1),
6465 w
->buffer
, beginning
);
6467 = Fnext_single_property_change (position
, Qmouse_face
,
6469 /* Record this as the current active region. */
6470 fast_find_position (w
, XFASTINT (before
),
6471 &dpyinfo
->mouse_face_beg_col
,
6472 &dpyinfo
->mouse_face_beg_row
,
6473 &dpyinfo
->mouse_face_beg_x
,
6474 &dpyinfo
->mouse_face_beg_y
);
6475 dpyinfo
->mouse_face_past_end
6476 = !fast_find_position (w
, XFASTINT (after
),
6477 &dpyinfo
->mouse_face_end_col
,
6478 &dpyinfo
->mouse_face_end_row
,
6479 &dpyinfo
->mouse_face_end_x
,
6480 &dpyinfo
->mouse_face_end_y
);
6481 dpyinfo
->mouse_face_window
= window
;
6482 dpyinfo
->mouse_face_face_id
6483 = face_at_buffer_position (w
, pos
, 0, 0,
6484 &ignore
, pos
+ 1, 1);
6486 /* Display it as active. */
6487 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6491 /* Look for a `help-echo' property. */
6495 /* Check overlays first. */
6497 for (i
= 0; i
< noverlays
&& !STRINGP (help
); ++i
)
6498 help
= Foverlay_get (overlay_vec
[i
], Qhelp_echo
);
6500 /* Try text properties. */
6502 && ((STRINGP (glyph
->object
)
6503 && glyph
->charpos
>= 0
6504 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6505 || (BUFFERP (glyph
->object
)
6506 && glyph
->charpos
>= BEGV
6507 && glyph
->charpos
< ZV
)))
6508 help
= Fget_text_property (make_number (glyph
->charpos
),
6509 Qhelp_echo
, glyph
->object
);
6517 current_buffer
= obuf
;
6523 redo_mouse_highlight ()
6525 if (!NILP (last_mouse_motion_frame
)
6526 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
6527 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
6528 last_mouse_motion_event
.x
,
6529 last_mouse_motion_event
.y
);
6534 /***********************************************************************
6536 ***********************************************************************/
6538 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
6539 struct glyph
**, int *, int *, int *));
6541 /* Tool-bar item index of the item on which a mouse button was pressed
6544 static int last_tool_bar_item
;
6547 /* Get information about the tool-bar item at position X/Y on frame F.
6548 Return in *GLYPH a pointer to the glyph of the tool-bar item in
6549 the current matrix of the tool-bar window of F, or NULL if not
6550 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
6551 item in F->current_tool_bar_items. Value is
6553 -1 if X/Y is not on a tool-bar item
6554 0 if X/Y is on the same item that was highlighted before.
6558 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
6561 struct glyph
**glyph
;
6562 int *hpos
, *vpos
, *prop_idx
;
6564 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6565 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6568 /* Find the glyph under X/Y. */
6569 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
);
6573 /* Get the start of this tool-bar item's properties in
6574 f->current_tool_bar_items. */
6575 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
6578 /* Is mouse on the highlighted item? */
6579 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
6580 && *vpos
>= dpyinfo
->mouse_face_beg_row
6581 && *vpos
<= dpyinfo
->mouse_face_end_row
6582 && (*vpos
> dpyinfo
->mouse_face_beg_row
6583 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
6584 && (*vpos
< dpyinfo
->mouse_face_end_row
6585 || *hpos
< dpyinfo
->mouse_face_end_col
6586 || dpyinfo
->mouse_face_past_end
))
6593 /* Handle mouse button event on the tool-bar of frame F, at
6594 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
6598 x_handle_tool_bar_click (f
, button_event
)
6600 XButtonEvent
*button_event
;
6602 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6603 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6604 int hpos
, vpos
, prop_idx
;
6605 struct glyph
*glyph
;
6606 Lisp_Object enabled_p
;
6607 int x
= button_event
->x
;
6608 int y
= button_event
->y
;
6610 /* If not on the highlighted tool-bar item, return. */
6611 frame_to_window_pixel_xy (w
, &x
, &y
);
6612 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
6615 /* If item is disabled, do nothing. */
6616 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
6617 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
6618 if (NILP (enabled_p
))
6621 if (button_event
->type
== ButtonPress
)
6623 /* Show item in pressed state. */
6624 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
6625 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
6626 last_tool_bar_item
= prop_idx
;
6630 Lisp_Object key
, frame
;
6631 struct input_event event
;
6633 /* Show item in released state. */
6634 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
6635 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
6637 key
= (XVECTOR (f
->current_tool_bar_items
)
6638 ->contents
[prop_idx
+ TOOL_BAR_ITEM_KEY
]);
6640 XSETFRAME (frame
, f
);
6641 event
.kind
= TOOL_BAR_EVENT
;
6642 event
.frame_or_window
= Fcons (frame
, Fcons (Qtool_bar
, Qnil
));
6643 kbd_buffer_store_event (&event
);
6645 event
.kind
= TOOL_BAR_EVENT
;
6646 event
.frame_or_window
= Fcons (frame
, key
);
6647 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
6648 button_event
->state
);
6649 kbd_buffer_store_event (&event
);
6650 last_tool_bar_item
= -1;
6655 /* Possibly highlight a tool-bar item on frame F when mouse moves to
6656 tool-bar window-relative coordinates X/Y. Called from
6657 note_mouse_highlight. */
6660 note_tool_bar_highlight (f
, x
, y
)
6664 Lisp_Object window
= f
->tool_bar_window
;
6665 struct window
*w
= XWINDOW (window
);
6666 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6668 struct glyph
*glyph
;
6669 struct glyph_row
*row
;
6671 Lisp_Object enabled_p
;
6673 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
6674 int mouse_down_p
, rc
;
6676 /* Function note_mouse_highlight is called with negative x(y
6677 values when mouse moves outside of the frame. */
6678 if (x
<= 0 || y
<= 0)
6680 clear_mouse_face (dpyinfo
);
6684 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
6687 /* Not on tool-bar item. */
6688 clear_mouse_face (dpyinfo
);
6692 /* On same tool-bar item as before. */
6695 clear_mouse_face (dpyinfo
);
6697 /* Mouse is down, but on different tool-bar item? */
6698 mouse_down_p
= (dpyinfo
->grabbed
6699 && f
== last_mouse_frame
6700 && FRAME_LIVE_P (f
));
6702 && last_tool_bar_item
!= prop_idx
)
6705 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
6706 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
6708 /* If tool-bar item is not enabled, don't highlight it. */
6709 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
6710 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
6711 if (!NILP (enabled_p
))
6713 /* Compute the x-position of the glyph. In front and past the
6714 image is a space. We include this is the highlighted area. */
6715 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6716 for (i
= x
= 0; i
< hpos
; ++i
)
6717 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
6719 /* Record this as the current active region. */
6720 dpyinfo
->mouse_face_beg_col
= hpos
;
6721 dpyinfo
->mouse_face_beg_row
= vpos
;
6722 dpyinfo
->mouse_face_beg_x
= x
;
6723 dpyinfo
->mouse_face_beg_y
= row
->y
;
6724 dpyinfo
->mouse_face_past_end
= 0;
6726 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
6727 dpyinfo
->mouse_face_end_row
= vpos
;
6728 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
6729 dpyinfo
->mouse_face_end_y
= row
->y
;
6730 dpyinfo
->mouse_face_window
= window
;
6731 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
6733 /* Display it as active. */
6734 show_mouse_face (dpyinfo
, draw
);
6735 dpyinfo
->mouse_face_image_state
= draw
;
6740 /* Set help_echo to a help string.to display for this tool-bar item.
6741 XTread_socket does the rest. */
6742 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
6743 ->contents
[prop_idx
+ TOOL_BAR_ITEM_HELP
]);
6744 if (!STRINGP (help_echo
))
6745 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
6746 ->contents
[prop_idx
+ TOOL_BAR_ITEM_CAPTION
]);
6751 /* Find the glyph matrix position of buffer position POS in window W.
6752 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
6753 current glyphs must be up to date. If POS is above window start
6754 return (0, 0, 0, 0). If POS is after end of W, return end of
6758 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
)
6761 int *hpos
, *vpos
, *x
, *y
;
6765 int maybe_next_line_p
= 0;
6766 int line_start_position
;
6767 int yb
= window_text_bottom_y (w
);
6768 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
6769 struct glyph_row
*best_row
= row
;
6770 int row_vpos
= 0, best_row_vpos
= 0;
6775 if (row
->used
[TEXT_AREA
])
6776 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
6778 line_start_position
= 0;
6780 if (line_start_position
> pos
)
6782 /* If the position sought is the end of the buffer,
6783 don't include the blank lines at the bottom of the window. */
6784 else if (line_start_position
== pos
6785 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
6787 maybe_next_line_p
= 1;
6790 else if (line_start_position
> 0)
6793 best_row_vpos
= row_vpos
;
6796 if (row
->y
+ row
->height
>= yb
)
6803 /* Find the right column within BEST_ROW. */
6805 current_x
= best_row
->x
;
6806 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
6808 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
6811 charpos
= glyph
->charpos
;
6815 *vpos
= best_row_vpos
;
6820 else if (charpos
> pos
)
6822 else if (charpos
> 0)
6825 current_x
+= glyph
->pixel_width
;
6828 /* If we're looking for the end of the buffer,
6829 and we didn't find it in the line we scanned,
6830 use the start of the following line. */
6831 if (maybe_next_line_p
)
6836 current_x
= best_row
->x
;
6839 *vpos
= best_row_vpos
;
6840 *hpos
= lastcol
+ 1;
6847 /* Display the active region described by mouse_face_*
6848 in its mouse-face if HL > 0, in its normal face if HL = 0. */
6851 show_mouse_face (dpyinfo
, draw
)
6852 struct x_display_info
*dpyinfo
;
6853 enum draw_glyphs_face draw
;
6855 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
6856 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
6858 int cursor_off_p
= 0;
6859 struct cursor_pos saved_cursor
;
6861 saved_cursor
= output_cursor
;
6863 /* If window is in the process of being destroyed, don't bother
6865 if (w
->current_matrix
== NULL
)
6868 /* Recognize when we are called to operate on rows that don't exist
6869 anymore. This can happen when a window is split. */
6870 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
6873 set_output_cursor (&w
->phys_cursor
);
6875 /* Note that mouse_face_beg_row etc. are window relative. */
6876 for (i
= dpyinfo
->mouse_face_beg_row
;
6877 i
<= dpyinfo
->mouse_face_end_row
;
6880 int start_hpos
, end_hpos
, start_x
;
6881 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
6883 /* Don't do anything if row doesn't have valid contents. */
6884 if (!row
->enabled_p
)
6887 /* For all but the first row, the highlight starts at column 0. */
6888 if (i
== dpyinfo
->mouse_face_beg_row
)
6890 start_hpos
= dpyinfo
->mouse_face_beg_col
;
6891 start_x
= dpyinfo
->mouse_face_beg_x
;
6899 if (i
== dpyinfo
->mouse_face_end_row
)
6900 end_hpos
= dpyinfo
->mouse_face_end_col
;
6902 end_hpos
= row
->used
[TEXT_AREA
];
6904 /* If the cursor's in the text we are about to rewrite, turn the
6906 if (!w
->pseudo_window_p
6907 && i
== output_cursor
.vpos
6908 && output_cursor
.hpos
>= start_hpos
- 1
6909 && output_cursor
.hpos
<= end_hpos
)
6911 x_update_window_cursor (w
, 0);
6915 if (end_hpos
> start_hpos
)
6916 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
6917 start_hpos
, end_hpos
, draw
, NULL
, NULL
, 0);
6920 /* If we turned the cursor off, turn it back on. */
6922 x_display_cursor (w
, 1,
6923 output_cursor
.hpos
, output_cursor
.vpos
,
6924 output_cursor
.x
, output_cursor
.y
);
6926 output_cursor
= saved_cursor
;
6930 /* Change the mouse cursor. */
6931 if (draw
== DRAW_NORMAL_TEXT
)
6932 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6933 f
->output_data
.x
->text_cursor
);
6934 else if (draw
== DRAW_MOUSE_FACE
)
6935 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6936 f
->output_data
.x
->cross_cursor
);
6938 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6939 f
->output_data
.x
->nontext_cursor
);
6942 /* Clear out the mouse-highlighted active region.
6943 Redraw it un-highlighted first. */
6946 clear_mouse_face (dpyinfo
)
6947 struct x_display_info
*dpyinfo
;
6952 if (! NILP (dpyinfo
->mouse_face_window
))
6953 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
6955 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6956 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6957 dpyinfo
->mouse_face_window
= Qnil
;
6960 /* Just discard the mouse face information for frame F, if any.
6961 This is used when the size of F is changed. */
6964 cancel_mouse_face (f
)
6968 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6970 window
= dpyinfo
->mouse_face_window
;
6971 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
6973 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6974 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6975 dpyinfo
->mouse_face_window
= Qnil
;
6979 static struct scroll_bar
*x_window_to_scroll_bar ();
6980 static void x_scroll_bar_report_motion ();
6982 /* Return the current position of the mouse.
6983 *fp should be a frame which indicates which display to ask about.
6985 If the mouse movement started in a scroll bar, set *fp, *bar_window,
6986 and *part to the frame, window, and scroll bar part that the mouse
6987 is over. Set *x and *y to the portion and whole of the mouse's
6988 position on the scroll bar.
6990 If the mouse movement started elsewhere, set *fp to the frame the
6991 mouse is on, *bar_window to nil, and *x and *y to the character cell
6994 Set *time to the server time-stamp for the time at which the mouse
6995 was at this position.
6997 Don't store anything if we don't have a valid set of values to report.
6999 This clears the mouse_moved flag, so we can wait for the next mouse
7003 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7006 Lisp_Object
*bar_window
;
7007 enum scroll_bar_part
*part
;
7009 unsigned long *time
;
7015 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7016 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7022 Window dummy_window
;
7025 Lisp_Object frame
, tail
;
7027 /* Clear the mouse-moved flag for every frame on this display. */
7028 FOR_EACH_FRAME (tail
, frame
)
7029 if (FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
7030 XFRAME (frame
)->mouse_moved
= 0;
7032 last_mouse_scroll_bar
= Qnil
;
7034 /* Figure out which root window we're on. */
7035 XQueryPointer (FRAME_X_DISPLAY (*fp
),
7036 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
7038 /* The root window which contains the pointer. */
7041 /* Trash which we can't trust if the pointer is on
7042 a different screen. */
7045 /* The position on that root window. */
7048 /* More trash we can't trust. */
7051 /* Modifier keys and pointer buttons, about which
7053 (unsigned int *) &dummy
);
7055 /* Now we have a position on the root; find the innermost window
7056 containing the pointer. */
7060 int parent_x
= 0, parent_y
= 0;
7065 /* XTranslateCoordinates can get errors if the window
7066 structure is changing at the same time this function
7067 is running. So at least we must not crash from them. */
7069 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
7071 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
7072 && FRAME_LIVE_P (last_mouse_frame
))
7074 /* If mouse was grabbed on a frame, give coords for that frame
7075 even if the mouse is now outside it. */
7076 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7078 /* From-window, to-window. */
7079 root
, FRAME_X_WINDOW (last_mouse_frame
),
7081 /* From-position, to-position. */
7082 root_x
, root_y
, &win_x
, &win_y
,
7086 f1
= last_mouse_frame
;
7092 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
7094 /* From-window, to-window. */
7097 /* From-position, to-position. */
7098 root_x
, root_y
, &win_x
, &win_y
,
7103 if (child
== None
|| child
== win
)
7111 /* Now we know that:
7112 win is the innermost window containing the pointer
7113 (XTC says it has no child containing the pointer),
7114 win_x and win_y are the pointer's position in it
7115 (XTC did this the last time through), and
7116 parent_x and parent_y are the pointer's position in win's parent.
7117 (They are what win_x and win_y were when win was child.
7118 If win is the root window, it has no parent, and
7119 parent_{x,y} are invalid, but that's okay, because we'll
7120 never use them in that case.) */
7122 /* Is win one of our frames? */
7123 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
7126 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
7129 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
7131 /* If not, is it one of our scroll bars? */
7134 struct scroll_bar
*bar
= x_window_to_scroll_bar (win
);
7138 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7144 if (f1
== 0 && insist
> 0)
7145 f1
= SELECTED_FRAME ();
7149 /* Ok, we found a frame. Store all the values.
7150 last_mouse_glyph is a rectangle used to reduce the
7151 generation of mouse events. To not miss any motion
7152 events, we must divide the frame into rectangles of the
7153 size of the smallest character that could be displayed
7154 on it, i.e. into the same rectangles that matrices on
7155 the frame are divided into. */
7157 #if OLD_REDISPLAY_CODE
7158 int ignore1
, ignore2
;
7159 pixel_to_glyph_coords (f1
, win_x
, win_y
, &ignore1
, &ignore2
,
7161 FRAME_X_DISPLAY_INFO (f1
)->grabbed
7165 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
7166 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
7170 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7171 round down even for negative values. */
7177 last_mouse_glyph
.width
= width
;
7178 last_mouse_glyph
.height
= height
;
7179 last_mouse_glyph
.x
= (x
+ width
- 1) / width
* width
;
7180 last_mouse_glyph
.y
= (y
+ height
- 1) / height
* height
;
7187 XSETINT (*x
, win_x
);
7188 XSETINT (*y
, win_y
);
7189 *time
= last_mouse_movement_time
;
7198 #ifdef USE_X_TOOLKIT
7200 /* Atimer callback function for TIMER. Called every 0.1s to process
7201 Xt timeouts, if needed. We must avoid calling XtAppPending as
7202 much as possible because that function does an implicit XFlush
7203 that slows us down. */
7206 x_process_timeouts (timer
)
7207 struct atimer
*timer
;
7209 if (toolkit_scroll_bar_interaction
|| popup_activated_flag
)
7212 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
7213 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
7218 #endif /* USE_X_TOOLKIT */
7221 /* Scroll bar support. */
7223 /* Given an X window ID, find the struct scroll_bar which manages it.
7224 This can be called in GC, so we have to make sure to strip off mark
7227 static struct scroll_bar
*
7228 x_window_to_scroll_bar (window_id
)
7233 for (tail
= Vframe_list
;
7234 XGCTYPE (tail
) == Lisp_Cons
;
7237 Lisp_Object frame
, bar
, condemned
;
7239 frame
= XCAR (tail
);
7240 /* All elements of Vframe_list should be frames. */
7241 if (! GC_FRAMEP (frame
))
7244 /* Scan this frame's scroll bar list for a scroll bar with the
7246 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
7247 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
7248 /* This trick allows us to search both the ordinary and
7249 condemned scroll bar lists with one loop. */
7250 ! GC_NILP (bar
) || (bar
= condemned
,
7253 bar
= XSCROLL_BAR (bar
)->next
)
7254 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
7255 return XSCROLL_BAR (bar
);
7263 /************************************************************************
7265 ************************************************************************/
7267 #if USE_TOOLKIT_SCROLL_BARS
7269 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
7270 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
7271 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
7272 struct scroll_bar
*));
7273 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
7277 /* Id of action hook installed for scroll bars. */
7279 static XtActionHookId action_hook_id
;
7281 /* Lisp window being scrolled. Set when starting to interact with
7282 a toolkit scroll bar, reset to nil when ending the interaction. */
7284 static Lisp_Object window_being_scrolled
;
7286 /* Last scroll bar part sent in xm_scroll_callback. */
7288 static int last_scroll_bar_part
;
7290 /* Whether this is an Xaw with arrow-scrollbars. This should imply
7291 that movements of 1/20 of the screen size are mapped to up/down. */
7293 static Boolean xaw3d_arrow_scroll
;
7295 /* Whether the drag scrolling maintains the mouse at the top of the
7296 thumb. If not, resizing the thumb needs to be done more carefully
7297 to avoid jerkyness. */
7299 static Boolean xaw3d_pick_top
;
7302 /* Action hook installed via XtAppAddActionHook when toolkit scroll
7303 bars are used.. The hook is responsible for detecting when
7304 the user ends an interaction with the scroll bar, and generates
7305 a `end-scroll' scroll_bar_click' event if so. */
7308 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
7311 XtPointer client_data
;
7315 Cardinal
*num_params
;
7321 scroll_bar_p
= XmIsScrollBar (widget
);
7322 end_action
= "Release";
7323 #else /* !USE_MOTIF i.e. use Xaw */
7324 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
7325 end_action
= "EndScroll";
7326 #endif /* USE_MOTIF */
7329 && strcmp (action_name
, end_action
) == 0
7330 && WINDOWP (window_being_scrolled
))
7334 x_send_scroll_bar_event (window_being_scrolled
,
7335 scroll_bar_end_scroll
, 0, 0);
7336 w
= XWINDOW (window_being_scrolled
);
7337 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
7338 window_being_scrolled
= Qnil
;
7339 last_scroll_bar_part
= -1;
7341 /* Xt timeouts no longer needed. */
7342 toolkit_scroll_bar_interaction
= 0;
7347 /* Send a client message with message type Xatom_Scrollbar for a
7348 scroll action to the frame of WINDOW. PART is a value identifying
7349 the part of the scroll bar that was clicked on. PORTION is the
7350 amount to scroll of a whole of WHOLE. */
7353 x_send_scroll_bar_event (window
, part
, portion
, whole
)
7355 int part
, portion
, whole
;
7358 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
7359 struct frame
*f
= XFRAME (XWINDOW (window
)->frame
);
7361 /* Construct a ClientMessage event to send to the frame. */
7362 ev
->type
= ClientMessage
;
7363 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
7364 ev
->display
= FRAME_X_DISPLAY (f
);
7365 ev
->window
= FRAME_X_WINDOW (f
);
7367 ev
->data
.l
[0] = (long) window
;
7368 ev
->data
.l
[1] = (long) part
;
7369 ev
->data
.l
[2] = (long) 0;
7370 ev
->data
.l
[3] = (long) portion
;
7371 ev
->data
.l
[4] = (long) whole
;
7373 /* Make Xt timeouts work while the scroll bar is active. */
7374 toolkit_scroll_bar_interaction
= 1;
7376 /* Setting the event mask to zero means that the message will
7377 be sent to the client that created the window, and if that
7378 window no longer exists, no event will be sent. */
7380 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
7385 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
7389 x_scroll_bar_to_input_event (event
, ievent
)
7391 struct input_event
*ievent
;
7393 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
7394 Lisp_Object window
= (Lisp_Object
) ev
->data
.l
[0];
7395 struct frame
*f
= XFRAME (XWINDOW (window
)->frame
);
7397 ievent
->kind
= scroll_bar_click
;
7398 ievent
->frame_or_window
= window
;
7399 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
7400 ievent
->part
= ev
->data
.l
[1];
7401 ievent
->code
= ev
->data
.l
[2];
7402 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
7403 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
7404 ievent
->modifiers
= 0;
7410 /* Minimum and maximum values used for Motif scroll bars. */
7413 #define XM_SB_MAX 10000000
7414 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
7417 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
7418 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
7419 CALL_DATA is a pointer a a XmScrollBarCallbackStruct. */
7422 xm_scroll_callback (widget
, client_data
, call_data
)
7424 XtPointer client_data
, call_data
;
7426 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7427 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
7429 int part
= -1, whole
= 0, portion
= 0;
7433 case XmCR_DECREMENT
:
7434 bar
->dragging
= Qnil
;
7435 part
= scroll_bar_up_arrow
;
7438 case XmCR_INCREMENT
:
7439 bar
->dragging
= Qnil
;
7440 part
= scroll_bar_down_arrow
;
7443 case XmCR_PAGE_DECREMENT
:
7444 bar
->dragging
= Qnil
;
7445 part
= scroll_bar_above_handle
;
7448 case XmCR_PAGE_INCREMENT
:
7449 bar
->dragging
= Qnil
;
7450 part
= scroll_bar_below_handle
;
7454 bar
->dragging
= Qnil
;
7455 part
= scroll_bar_to_top
;
7458 case XmCR_TO_BOTTOM
:
7459 bar
->dragging
= Qnil
;
7460 part
= scroll_bar_to_bottom
;
7466 int dragging_down_p
= (INTEGERP (bar
->dragging
)
7467 && XINT (bar
->dragging
) <= cs
->value
);
7469 /* Get the slider size. */
7471 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
7474 /* At the max position of the scroll bar, do a line-wise
7475 movement. Without doing anything, the LessTif scroll bar
7476 calls us with the same cs->value again and again. If we
7477 want to make sure that we can reach the end of the buffer,
7478 we have to do something.
7480 Implementation note: setting bar->dragging always to
7481 cs->value gives a smoother movement at the max position.
7482 Setting it to nil when doing line-wise movement gives
7483 a better slider behavior. */
7485 if (cs
->value
+ slider_size
== XM_SB_MAX
7487 && last_scroll_bar_part
== scroll_bar_down_arrow
))
7489 part
= scroll_bar_down_arrow
;
7490 bar
->dragging
= Qnil
;
7494 whole
= XM_SB_RANGE
;
7495 portion
= min (cs
->value
- XM_SB_MIN
, XM_SB_MAX
- slider_size
);
7496 part
= scroll_bar_handle
;
7497 bar
->dragging
= make_number (cs
->value
);
7502 case XmCR_VALUE_CHANGED
:
7508 window_being_scrolled
= bar
->window
;
7509 last_scroll_bar_part
= part
;
7510 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
7515 #else /* !USE_MOTIF, i.e. Xaw. */
7518 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
7519 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
7520 scroll bar struct. CALL_DATA is a pointer to a float saying where
7524 xaw_jump_callback (widget
, client_data
, call_data
)
7526 XtPointer client_data
, call_data
;
7528 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7529 float top
= *(float *) call_data
;
7531 int whole
, portion
, height
;
7534 /* Get the size of the thumb, a value between 0 and 1. */
7536 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
7540 portion
= shown
< 1 ? top
* whole
: 0;
7542 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
7543 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
7544 the bottom, so we force the scrolling whenever we see that we're
7545 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
7546 we try to ensure that we always stay two pixels away from the
7548 part
= scroll_bar_down_arrow
;
7550 part
= scroll_bar_handle
;
7552 window_being_scrolled
= bar
->window
;
7553 bar
->dragging
= make_number (portion
);
7554 last_scroll_bar_part
= part
;
7555 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
7559 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
7560 i.e. line or page up or down. WIDGET is the Xaw scroll bar
7561 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
7562 the scroll bar. CALL_DATA is an integer specifying the action that
7563 has taken place. It's magnitude is in the range 0..height of the
7564 scroll bar. Negative values mean scroll towards buffer start.
7565 Values < height of scroll bar mean line-wise movement. */
7568 xaw_scroll_callback (widget
, client_data
, call_data
)
7570 XtPointer client_data
, call_data
;
7572 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
7573 int position
= (int) call_data
;
7577 /* Get the height of the scroll bar. */
7579 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
7582 if (abs (position
) >= height
)
7583 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
7585 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
7586 it maps line-movement to call_data = max(5, height/20). */
7587 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
7588 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
7590 part
= scroll_bar_move_ratio
;
7592 window_being_scrolled
= bar
->window
;
7593 bar
->dragging
= Qnil
;
7594 last_scroll_bar_part
= part
;
7595 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
7599 #endif /* not USE_MOTIF */
7602 /* Create the widget for scroll bar BAR on frame F. Record the widget
7603 and X window of the scroll bar in BAR. */
7606 x_create_toolkit_scroll_bar (f
, bar
)
7608 struct scroll_bar
*bar
;
7614 char *scroll_bar_name
= "verticalScrollBar";
7615 unsigned long pixel
;
7620 /* LessTif 0.85, problems:
7622 1. When the mouse if over the scroll bar, the scroll bar will
7623 get keyboard events. I didn't find a way to turn this off.
7625 2. Do we have to explicitly set the cursor to get an arrow
7626 cursor (see below)? */
7628 /* Set resources. Create the widget. */
7629 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
7630 XtSetArg (av
[ac
], XmNminimum
, XM_SB_MIN
); ++ac
;
7631 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
7632 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
7633 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
7634 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
7635 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
7637 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
7640 XtSetArg (av
[ac
], XmNforeground
, pixel
);
7644 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
7647 XtSetArg (av
[ac
], XmNbackground
, pixel
);
7651 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
7652 scroll_bar_name
, av
, ac
);
7654 /* Add one callback for everything that can happen. */
7655 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
7657 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
7659 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
7661 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
7663 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
7665 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
7667 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
7670 /* Realize the widget. Only after that is the X window created. */
7671 XtRealizeWidget (widget
);
7673 /* Set the cursor to an arrow. I didn't find a resource to do that.
7674 And I'm wondering why it hasn't an arrow cursor by default. */
7675 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
7676 f
->output_data
.x
->nontext_cursor
);
7678 #else /* !USE_MOTIF i.e. use Xaw */
7680 /* Set resources. Create the widget. The background of the
7681 Xaw3d scroll bar widget is a little bit light for my taste.
7682 We don't alter it here to let users change it according
7683 to their taste with `emacs*verticalScrollBar.background: xxx'. */
7684 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
7685 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
7686 /* For smoother scrolling with Xaw3d -sm */
7687 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
7688 /* XtSetArg (av[ac], XtNbeNiceToColormap, True); ++ac; */
7690 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
7693 XtSetArg (av
[ac
], XtNforeground
, pixel
);
7697 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
7700 XtSetArg (av
[ac
], XtNbackground
, pixel
);
7704 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
7705 f
->output_data
.x
->edit_widget
, av
, ac
);
7709 char *val
= initial
;
7710 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
7711 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
7713 { /* ARROW_SCROLL */
7714 xaw3d_arrow_scroll
= True
;
7715 /* Isn't that just a personal preference ? -sm */
7716 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
7720 /* Define callbacks. */
7721 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
7722 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
7725 /* Realize the widget. Only after that is the X window created. */
7726 XtRealizeWidget (widget
);
7728 #endif /* !USE_MOTIF */
7730 /* Install an action hook that let's us detect when the user
7731 finishes interacting with a scroll bar. */
7732 if (action_hook_id
== 0)
7733 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
7735 /* Remember X window and widget in the scroll bar vector. */
7736 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
7737 xwindow
= XtWindow (widget
);
7738 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
7744 /* Set the thumb size and position of scroll bar BAR. We are currently
7745 displaying PORTION out of a whole WHOLE, and our position POSITION. */
7748 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
7749 struct scroll_bar
*bar
;
7750 int portion
, position
, whole
;
7753 Widget widget
= SCROLL_BAR_X_WIDGET (bar
);
7759 top
= (float) position
/ whole
;
7760 shown
= (float) portion
/ whole
;
7768 Boolean arrow1_selected
, arrow2_selected
;
7769 unsigned char flags
;
7770 XmScrollBarWidget sb
;
7772 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
7773 is the scroll bar's maximum and MIN is the scroll bar's minimum
7775 size
= shown
* XM_SB_RANGE
;
7776 size
= min (size
, XM_SB_RANGE
);
7777 size
= max (size
, 1);
7779 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
7780 value
= top
* XM_SB_RANGE
;
7781 value
= min (value
, XM_SB_MAX
- size
);
7782 value
= max (value
, XM_SB_MIN
);
7784 /* LessTif: Calling XmScrollBarSetValues after an increment or
7785 decrement turns off auto-repeat LessTif-internally. This can
7786 be seen in ScrollBar.c which resets Arrow1Selected and
7787 Arrow2Selected. It also sets internal flags so that LessTif
7788 believes the mouse is in the slider. We either have to change
7789 our code, or work around that by accessing private data. */
7791 sb
= (XmScrollBarWidget
) widget
;
7792 arrow1_selected
= sb
->scrollBar
.arrow1_selected
;
7793 arrow2_selected
= sb
->scrollBar
.arrow2_selected
;
7794 flags
= sb
->scrollBar
.flags
;
7796 if (NILP (bar
->dragging
))
7797 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
7798 else if (last_scroll_bar_part
== scroll_bar_down_arrow
)
7799 /* This has the negative side effect that the slider value is
7800 not what it would be if we scrolled here using line-wise or
7801 page-wise movement. */
7802 XmScrollBarSetValues (widget
, value
, XM_SB_RANGE
- value
, 0, 0, False
);
7805 /* If currently dragging, only update the slider size.
7806 This reduces flicker effects. */
7807 int old_value
, old_size
, increment
, page_increment
;
7809 XmScrollBarGetValues (widget
, &old_value
, &old_size
,
7810 &increment
, &page_increment
);
7811 XmScrollBarSetValues (widget
, old_value
,
7812 min (size
, XM_SB_RANGE
- old_value
),
7816 sb
->scrollBar
.arrow1_selected
= arrow1_selected
;
7817 sb
->scrollBar
.arrow2_selected
= arrow2_selected
;
7818 sb
->scrollBar
.flags
= flags
;
7820 #else /* !USE_MOTIF i.e. use Xaw */
7822 float old_top
, old_shown
;
7824 XtVaGetValues (widget
,
7825 XtNtopOfThumb
, &old_top
,
7826 XtNshown
, &old_shown
,
7830 /* Massage the top+shown values. */
7831 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
7832 top
= max (0, min (1, top
));
7835 /* Keep two pixels available for moving the thumb down. */
7836 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
7838 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
7839 check that your system's configuration file contains a define
7840 for `NARROWPROTO'. See s/freebsd.h for an example. */
7841 if (top
!= old_top
|| shown
!= old_shown
)
7843 if (NILP (bar
->dragging
))
7844 XawScrollbarSetThumb (widget
, top
, shown
);
7848 ScrollbarWidget sb
= (ScrollbarWidget
) widget
;
7851 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
7852 if (xaw3d_arrow_scroll
)
7854 /* Xaw3d stupidly ignores resize requests while dragging
7855 so we have to make it believe it's not in dragging mode. */
7856 scroll_mode
= sb
->scrollbar
.scroll_mode
;
7857 if (scroll_mode
== 2)
7858 sb
->scrollbar
.scroll_mode
= 0;
7861 /* Try to make the scrolling a tad smoother. */
7862 if (!xaw3d_pick_top
)
7863 shown
= min (shown
, old_shown
);
7865 XawScrollbarSetThumb (widget
, top
, shown
);
7868 if (xaw3d_arrow_scroll
&& scroll_mode
== 2)
7869 sb
->scrollbar
.scroll_mode
= scroll_mode
;
7874 #endif /* !USE_MOTIF */
7879 #endif /* USE_TOOLKIT_SCROLL_BARS */
7883 /************************************************************************
7884 Scroll bars, general
7885 ************************************************************************/
7887 /* Create a scroll bar and return the scroll bar vector for it. W is
7888 the Emacs window on which to create the scroll bar. TOP, LEFT,
7889 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
7892 static struct scroll_bar
*
7893 x_scroll_bar_create (w
, top
, left
, width
, height
)
7895 int top
, left
, width
, height
;
7897 struct frame
*f
= XFRAME (w
->frame
);
7898 struct scroll_bar
*bar
7899 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
7903 #if USE_TOOLKIT_SCROLL_BARS
7904 x_create_toolkit_scroll_bar (f
, bar
);
7905 #else /* not USE_TOOLKIT_SCROLL_BARS */
7907 XSetWindowAttributes a
;
7911 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
7912 if (a
.background_pixel
== -1)
7913 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
7915 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
7916 | ButtonMotionMask
| PointerMotionHintMask
7918 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
7920 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
7922 /* Clear the area of W that will serve as a scroll bar. This is
7923 for the case that a window has been split horizontally. In
7924 this case, no clear_frame is generated to reduce flickering. */
7925 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7927 window_box_height (w
), False
);
7929 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7930 /* Position and size of scroll bar. */
7931 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
7933 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
7935 /* Border width, depth, class, and visual. */
7942 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
7944 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7946 XSETWINDOW (bar
->window
, w
);
7947 XSETINT (bar
->top
, top
);
7948 XSETINT (bar
->left
, left
);
7949 XSETINT (bar
->width
, width
);
7950 XSETINT (bar
->height
, height
);
7951 XSETINT (bar
->start
, 0);
7952 XSETINT (bar
->end
, 0);
7953 bar
->dragging
= Qnil
;
7955 /* Add bar to its frame's list of scroll bars. */
7956 bar
->next
= FRAME_SCROLL_BARS (f
);
7958 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
7959 if (!NILP (bar
->next
))
7960 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
7962 /* Map the window/widget. */
7963 #if USE_TOOLKIT_SCROLL_BARS
7964 XtMapWidget (SCROLL_BAR_X_WIDGET (bar
));
7965 XtConfigureWidget (SCROLL_BAR_X_WIDGET (bar
),
7966 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
7968 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
7970 #else /* not USE_TOOLKIT_SCROLL_BARS */
7971 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
7972 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7979 /* Draw BAR's handle in the proper position.
7981 If the handle is already drawn from START to END, don't bother
7982 redrawing it, unless REBUILD is non-zero; in that case, always
7983 redraw it. (REBUILD is handy for drawing the handle after expose
7986 Normally, we want to constrain the start and end of the handle to
7987 fit inside its rectangle, but if the user is dragging the scroll
7988 bar handle, we want to let them drag it down all the way, so that
7989 the bar's top is as far down as it goes; otherwise, there's no way
7990 to move to the very end of the buffer. */
7992 #ifndef USE_TOOLKIT_SCROLL_BARS
7995 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
7996 struct scroll_bar
*bar
;
8000 int dragging
= ! NILP (bar
->dragging
);
8001 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8002 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8003 GC gc
= f
->output_data
.x
->normal_gc
;
8005 /* If the display is already accurate, do nothing. */
8007 && start
== XINT (bar
->start
)
8008 && end
== XINT (bar
->end
))
8014 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
8015 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8016 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8018 /* Make sure the values are reasonable, and try to preserve
8019 the distance between start and end. */
8021 int length
= end
- start
;
8025 else if (start
> top_range
)
8027 end
= start
+ length
;
8031 else if (end
> top_range
&& ! dragging
)
8035 /* Store the adjusted setting in the scroll bar. */
8036 XSETINT (bar
->start
, start
);
8037 XSETINT (bar
->end
, end
);
8039 /* Clip the end position, just for display. */
8040 if (end
> top_range
)
8043 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
8044 below top positions, to make sure the handle is always at least
8045 that many pixels tall. */
8046 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8048 /* Draw the empty space above the handle. Note that we can't clear
8049 zero-height areas; that means "clear to end of window." */
8051 XClearArea (FRAME_X_DISPLAY (f
), w
,
8053 /* x, y, width, height, and exposures. */
8054 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8055 VERTICAL_SCROLL_BAR_TOP_BORDER
,
8056 inside_width
, start
,
8059 /* Change to proper foreground color if one is specified. */
8060 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8061 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8062 f
->output_data
.x
->scroll_bar_foreground_pixel
);
8064 /* Draw the handle itself. */
8065 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8067 /* x, y, width, height */
8068 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8069 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
8070 inside_width
, end
- start
);
8072 /* Restore the foreground color of the GC if we changed it above. */
8073 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8074 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
8075 f
->output_data
.x
->foreground_pixel
);
8077 /* Draw the empty space below the handle. Note that we can't
8078 clear zero-height areas; that means "clear to end of window." */
8079 if (end
< inside_height
)
8080 XClearArea (FRAME_X_DISPLAY (f
), w
,
8082 /* x, y, width, height, and exposures. */
8083 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
8084 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
8085 inside_width
, inside_height
- end
,
8093 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8095 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
8099 x_scroll_bar_remove (bar
)
8100 struct scroll_bar
*bar
;
8104 #if USE_TOOLKIT_SCROLL_BARS
8105 XtDestroyWidget (SCROLL_BAR_X_WIDGET (bar
));
8106 #else /* not USE_TOOLKIT_SCROLL_BARS */
8108 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8109 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
8111 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8113 /* Disassociate this scroll bar from its window. */
8114 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
8120 /* Set the handle of the vertical scroll bar for WINDOW to indicate
8121 that we are displaying PORTION characters out of a total of WHOLE
8122 characters, starting at POSITION. If WINDOW has no scroll bar,
8126 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
8128 int portion
, whole
, position
;
8130 struct frame
*f
= XFRAME (w
->frame
);
8131 struct scroll_bar
*bar
;
8132 int top
, height
, left
, sb_left
, width
, sb_width
;
8133 int window_x
, window_y
, window_width
, window_height
;
8135 /* Get window dimensions. */
8136 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
8138 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
8139 height
= window_height
;
8141 /* Compute the left edge of the scroll bar area. */
8142 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8143 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
8145 left
= XFASTINT (w
->left
);
8146 left
*= CANON_X_UNIT (f
);
8147 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
8149 /* Compute the width of the scroll bar which might be less than
8150 the width of the area reserved for the scroll bar. */
8151 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
8152 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
8156 /* Compute the left edge of the scroll bar. */
8157 #ifdef USE_TOOLKIT_SCROLL_BARS
8158 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8159 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
8161 sb_left
= left
+ (width
- sb_width
) / 2;
8163 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8164 sb_left
= left
+ width
- sb_width
;
8169 /* Does the scroll bar exist yet? */
8170 if (NILP (w
->vertical_scroll_bar
))
8173 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8174 left
, top
, width
, height
, False
);
8176 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
8180 /* It may just need to be moved and resized. */
8181 unsigned int mask
= 0;
8183 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
8187 if (sb_left
!= XINT (bar
->left
))
8189 if (top
!= XINT (bar
->top
))
8191 if (sb_width
!= XINT (bar
->width
))
8193 if (height
!= XINT (bar
->height
))
8196 #ifdef USE_TOOLKIT_SCROLL_BARS
8198 /* Since toolkit scroll bars are smaller than the space reserved
8199 for them on the frame, we have to clear "under" them. */
8200 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8201 left
, top
, width
, height
, False
);
8203 /* Move/size the scroll bar widget. */
8205 XtConfigureWidget (SCROLL_BAR_X_WIDGET (bar
),
8206 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8208 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8211 #else /* not USE_TOOLKIT_SCROLL_BARS */
8213 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
8215 /* Clear areas not covered by the scroll bar. This makes sure a
8216 previous mode line display is cleared after C-x 2 C-x 1, for
8217 example. Non-toolkit scroll bars are as wide as the area
8218 reserved for scroll bars - trim at both sides. */
8219 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8220 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8222 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8223 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8224 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8228 /* Move/size the scroll bar window. */
8233 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
8235 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
8237 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
8241 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8243 /* Remember new settings. */
8244 XSETINT (bar
->left
, sb_left
);
8245 XSETINT (bar
->top
, top
);
8246 XSETINT (bar
->width
, sb_width
);
8247 XSETINT (bar
->height
, height
);
8252 #if USE_TOOLKIT_SCROLL_BARS
8253 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
8254 #else /* not USE_TOOLKIT_SCROLL_BARS */
8255 /* Set the scroll bar's current state, unless we're currently being
8257 if (NILP (bar
->dragging
))
8259 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
8262 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
8265 int start
= ((double) position
* top_range
) / whole
;
8266 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
8267 x_scroll_bar_set_handle (bar
, start
, end
, 0);
8270 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8272 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
8276 /* The following three hooks are used when we're doing a thorough
8277 redisplay of the frame. We don't explicitly know which scroll bars
8278 are going to be deleted, because keeping track of when windows go
8279 away is a real pain - "Can you say set-window-configuration, boys
8280 and girls?" Instead, we just assert at the beginning of redisplay
8281 that *all* scroll bars are to be removed, and then save a scroll bar
8282 from the fiery pit when we actually redisplay its window. */
8284 /* Arrange for all scroll bars on FRAME to be removed at the next call
8285 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
8286 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
8289 XTcondemn_scroll_bars (frame
)
8292 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
8293 while (! NILP (FRAME_SCROLL_BARS (frame
)))
8296 bar
= FRAME_SCROLL_BARS (frame
);
8297 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
8298 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
8299 XSCROLL_BAR (bar
)->prev
= Qnil
;
8300 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
8301 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
8302 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
8306 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
8307 Note that WINDOW isn't necessarily condemned at all. */
8309 XTredeem_scroll_bar (window
)
8310 struct window
*window
;
8312 struct scroll_bar
*bar
;
8314 /* We can't redeem this window's scroll bar if it doesn't have one. */
8315 if (NILP (window
->vertical_scroll_bar
))
8318 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
8320 /* Unlink it from the condemned list. */
8322 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
8324 if (NILP (bar
->prev
))
8326 /* If the prev pointer is nil, it must be the first in one of
8328 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
8329 /* It's not condemned. Everything's fine. */
8331 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
8332 window
->vertical_scroll_bar
))
8333 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
8335 /* If its prev pointer is nil, it must be at the front of
8336 one or the other! */
8340 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
8342 if (! NILP (bar
->next
))
8343 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
8345 bar
->next
= FRAME_SCROLL_BARS (f
);
8347 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8348 if (! NILP (bar
->next
))
8349 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8353 /* Remove all scroll bars on FRAME that haven't been saved since the
8354 last call to `*condemn_scroll_bars_hook'. */
8357 XTjudge_scroll_bars (f
)
8360 Lisp_Object bar
, next
;
8362 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
8364 /* Clear out the condemned list now so we won't try to process any
8365 more events on the hapless scroll bars. */
8366 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
8368 for (; ! NILP (bar
); bar
= next
)
8370 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
8372 x_scroll_bar_remove (b
);
8375 b
->next
= b
->prev
= Qnil
;
8378 /* Now there should be no references to the condemned scroll bars,
8379 and they should get garbage-collected. */
8383 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
8384 is a no-op when using toolkit scroll bars.
8386 This may be called from a signal handler, so we have to ignore GC
8390 x_scroll_bar_expose (bar
, event
)
8391 struct scroll_bar
*bar
;
8394 #ifndef USE_TOOLKIT_SCROLL_BARS
8396 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8397 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8398 GC gc
= f
->output_data
.x
->normal_gc
;
8399 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
8403 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
8405 /* Draw a one-pixel border just inside the edges of the scroll bar. */
8406 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
8408 /* x, y, width, height */
8410 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
8411 XINT (bar
->height
) - 1);
8415 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8418 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
8419 is set to something other than no_event, it is enqueued.
8421 This may be called from a signal handler, so we have to ignore GC
8424 #ifndef USE_TOOLKIT_SCROLL_BARS
8427 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
8428 struct scroll_bar
*bar
;
8430 struct input_event
*emacs_event
;
8432 if (! GC_WINDOWP (bar
->window
))
8435 emacs_event
->kind
= scroll_bar_click
;
8436 emacs_event
->code
= event
->xbutton
.button
- Button1
;
8437 emacs_event
->modifiers
8438 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
8439 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
8440 event
->xbutton
.state
)
8441 | (event
->type
== ButtonRelease
8444 emacs_event
->frame_or_window
= bar
->window
;
8445 emacs_event
->timestamp
= event
->xbutton
.time
;
8448 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8450 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8453 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8454 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
8457 if (y
> top_range
) y
= top_range
;
8459 if (y
< XINT (bar
->start
))
8460 emacs_event
->part
= scroll_bar_above_handle
;
8461 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
8462 emacs_event
->part
= scroll_bar_handle
;
8464 emacs_event
->part
= scroll_bar_below_handle
;
8466 /* Just because the user has clicked on the handle doesn't mean
8467 they want to drag it. Lisp code needs to be able to decide
8468 whether or not we're dragging. */
8470 /* If the user has just clicked on the handle, record where they're
8472 if (event
->type
== ButtonPress
8473 && emacs_event
->part
== scroll_bar_handle
)
8474 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
8477 /* If the user has released the handle, set it to its final position. */
8478 if (event
->type
== ButtonRelease
8479 && ! NILP (bar
->dragging
))
8481 int new_start
= y
- XINT (bar
->dragging
);
8482 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8484 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8485 bar
->dragging
= Qnil
;
8488 /* Same deal here as the other #if 0. */
8490 /* Clicks on the handle are always reported as occurring at the top of
8492 if (emacs_event
->part
== scroll_bar_handle
)
8493 emacs_event
->x
= bar
->start
;
8495 XSETINT (emacs_event
->x
, y
);
8497 XSETINT (emacs_event
->x
, y
);
8500 XSETINT (emacs_event
->y
, top_range
);
8504 /* Handle some mouse motion while someone is dragging the scroll bar.
8506 This may be called from a signal handler, so we have to ignore GC
8510 x_scroll_bar_note_movement (bar
, event
)
8511 struct scroll_bar
*bar
;
8514 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
8516 last_mouse_movement_time
= event
->xmotion
.time
;
8519 XSETVECTOR (last_mouse_scroll_bar
, bar
);
8521 /* If we're dragging the bar, display it. */
8522 if (! GC_NILP (bar
->dragging
))
8524 /* Where should the handle be now? */
8525 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
8527 if (new_start
!= XINT (bar
->start
))
8529 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8531 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8536 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8538 /* Return information to the user about the current position of the mouse
8539 on the scroll bar. */
8542 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
8544 Lisp_Object
*bar_window
;
8545 enum scroll_bar_part
*part
;
8547 unsigned long *time
;
8549 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
8550 Window w
= SCROLL_BAR_X_WINDOW (bar
);
8551 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8553 Window dummy_window
;
8555 unsigned int dummy_mask
;
8559 /* Get the mouse's position relative to the scroll bar window, and
8561 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
8563 /* Root, child, root x and root y. */
8564 &dummy_window
, &dummy_window
,
8565 &dummy_coord
, &dummy_coord
,
8567 /* Position relative to scroll bar. */
8570 /* Mouse buttons and modifier keys. */
8577 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
8580 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8582 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
8584 if (! NILP (bar
->dragging
))
8585 win_y
-= XINT (bar
->dragging
);
8589 if (win_y
> top_range
)
8593 *bar_window
= bar
->window
;
8595 if (! NILP (bar
->dragging
))
8596 *part
= scroll_bar_handle
;
8597 else if (win_y
< XINT (bar
->start
))
8598 *part
= scroll_bar_above_handle
;
8599 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
8600 *part
= scroll_bar_handle
;
8602 *part
= scroll_bar_below_handle
;
8604 XSETINT (*x
, win_y
);
8605 XSETINT (*y
, top_range
);
8608 last_mouse_scroll_bar
= Qnil
;
8611 *time
= last_mouse_movement_time
;
8617 /* The screen has been cleared so we may have changed foreground or
8618 background colors, and the scroll bars may need to be redrawn.
8619 Clear out the scroll bars, and ask for expose events, so we can
8623 x_scroll_bar_clear (f
)
8626 #ifndef USE_TOOLKIT_SCROLL_BARS
8629 /* We can have scroll bars even if this is 0,
8630 if we just turned off scroll bar mode.
8631 But in that case we should not clear them. */
8632 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8633 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
8634 bar
= XSCROLL_BAR (bar
)->next
)
8635 XClearArea (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
8637 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8640 /* This processes Expose events from the menu-bar specific X event
8641 loop in xmenu.c. This allows to redisplay the frame if necessary
8642 when handling menu-bar or pop-up items. */
8645 process_expose_from_menu (event
)
8649 struct x_display_info
*dpyinfo
;
8650 int frame_exposed_p
= 0;
8654 dpyinfo
= x_display_info_for_display (event
.xexpose
.display
);
8655 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
8658 if (f
->async_visible
== 0)
8660 f
->async_visible
= 1;
8661 f
->async_iconified
= 0;
8662 f
->output_data
.x
->has_been_visible
= 1;
8663 SET_FRAME_GARBAGED (f
);
8667 expose_frame (x_window_to_frame (dpyinfo
, event
.xexpose
.window
),
8668 event
.xexpose
.x
, event
.xexpose
.y
,
8669 event
.xexpose
.width
, event
.xexpose
.height
);
8670 frame_exposed_p
= 1;
8675 struct scroll_bar
*bar
8676 = x_window_to_scroll_bar (event
.xexpose
.window
);
8679 x_scroll_bar_expose (bar
, &event
);
8683 return frame_exposed_p
;
8686 /* Define a queue to save up SelectionRequest events for later handling. */
8688 struct selection_event_queue
8691 struct selection_event_queue
*next
;
8694 static struct selection_event_queue
*queue
;
8696 /* Nonzero means queue up certain events--don't process them yet. */
8698 static int x_queue_selection_requests
;
8700 /* Queue up an X event *EVENT, to be processed later. */
8703 x_queue_event (f
, event
)
8707 struct selection_event_queue
*queue_tmp
8708 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
8710 if (queue_tmp
!= NULL
)
8712 queue_tmp
->event
= *event
;
8713 queue_tmp
->next
= queue
;
8718 /* Take all the queued events and put them back
8719 so that they get processed afresh. */
8722 x_unqueue_events (display
)
8725 while (queue
!= NULL
)
8727 struct selection_event_queue
*queue_tmp
= queue
;
8728 XPutBackEvent (display
, &queue_tmp
->event
);
8729 queue
= queue_tmp
->next
;
8730 xfree ((char *)queue_tmp
);
8734 /* Start queuing SelectionRequest events. */
8737 x_start_queuing_selection_requests (display
)
8740 x_queue_selection_requests
++;
8743 /* Stop queuing SelectionRequest events. */
8746 x_stop_queuing_selection_requests (display
)
8749 x_queue_selection_requests
--;
8750 x_unqueue_events (display
);
8753 /* The main X event-reading loop - XTread_socket. */
8755 /* Time stamp of enter window event. This is only used by XTread_socket,
8756 but we have to put it out here, since static variables within functions
8757 sometimes don't work. */
8759 static Time enter_timestamp
;
8761 /* This holds the state XLookupString needs to implement dead keys
8762 and other tricks known as "compose processing". _X Window System_
8763 says that a portable program can't use this, but Stephen Gildea assures
8764 me that letting the compiler initialize it to zeros will work okay.
8766 This must be defined outside of XTread_socket, for the same reasons
8767 given for enter_time stamp, above. */
8769 static XComposeStatus compose_status
;
8771 /* Record the last 100 characters stored
8772 to help debug the loss-of-chars-during-GC problem. */
8774 static int temp_index
;
8775 static short temp_buffer
[100];
8777 /* Set this to nonzero to fake an "X I/O error"
8778 on a particular display. */
8780 struct x_display_info
*XTread_socket_fake_io_error
;
8782 /* When we find no input here, we occasionally do a no-op command
8783 to verify that the X server is still running and we can still talk with it.
8784 We try all the open displays, one by one.
8785 This variable is used for cycling thru the displays. */
8787 static struct x_display_info
*next_noop_dpyinfo
;
8789 #define SET_SAVED_MENU_EVENT(size) \
8792 if (f->output_data.x->saved_menu_event == 0) \
8793 f->output_data.x->saved_menu_event \
8794 = (XEvent *) xmalloc (sizeof (XEvent)); \
8795 bcopy (&event, f->output_data.x->saved_menu_event, size); \
8796 if (numchars >= 1) \
8798 bufp->kind = menu_bar_activate_event; \
8799 XSETFRAME (bufp->frame_or_window, f); \
8807 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
8808 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
8810 /* Read events coming from the X server.
8811 This routine is called by the SIGIO handler.
8812 We return as soon as there are no more events to be read.
8814 Events representing keys are stored in buffer BUFP,
8815 which can hold up to NUMCHARS characters.
8816 We return the number of characters stored into the buffer,
8817 thus pretending to be `read'.
8819 EXPECTED is nonzero if the caller knows input is available. */
8822 XTread_socket (sd
, bufp
, numchars
, expected
)
8824 /* register */ struct input_event
*bufp
;
8825 /* register */ int numchars
;
8832 int event_found
= 0;
8833 struct x_display_info
*dpyinfo
;
8835 if (interrupt_input_blocked
)
8837 interrupt_input_pending
= 1;
8841 interrupt_input_pending
= 0;
8844 /* So people can tell when we have read the available input. */
8845 input_signal_count
++;
8848 abort (); /* Don't think this happens. */
8850 /* Find the display we are supposed to read input for.
8851 It's the one communicating on descriptor SD. */
8852 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
8854 #if 0 /* This ought to be unnecessary; let's verify it. */
8856 /* If available, Xlib uses FIOSNBIO to make the socket
8857 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
8858 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
8859 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
8860 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
8861 #endif /* ! defined (FIOSNBIO) */
8864 #if 0 /* This code can't be made to work, with multiple displays,
8865 and appears not to be used on any system any more.
8866 Also keyboard.c doesn't turn O_NDELAY on and off
8867 for X connections. */
8870 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
8872 extern int read_alarm_should_throw
;
8873 read_alarm_should_throw
= 1;
8874 XPeekEvent (dpyinfo
->display
, &event
);
8875 read_alarm_should_throw
= 0;
8877 #endif /* HAVE_SELECT */
8881 /* For debugging, this gives a way to fake an I/O error. */
8882 if (dpyinfo
== XTread_socket_fake_io_error
)
8884 XTread_socket_fake_io_error
= 0;
8885 x_io_error_quitter (dpyinfo
->display
);
8888 while (XPending (dpyinfo
->display
))
8890 XNextEvent (dpyinfo
->display
, &event
);
8894 /* Filter events for the current X input method.
8895 XFilterEvent returns non-zero if the input method has
8896 consumed the event. We pass the frame's X window to
8897 XFilterEvent because that's the one for which the IC
8899 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
8900 event
.xclient
.window
);
8901 if (XFilterEvent (&event
, f1
? FRAME_X_WINDOW (f1
) : None
))
8911 if (event
.xclient
.message_type
8912 == dpyinfo
->Xatom_wm_protocols
8913 && event
.xclient
.format
== 32)
8915 if (event
.xclient
.data
.l
[0]
8916 == dpyinfo
->Xatom_wm_take_focus
)
8918 /* Use x_any_window_to_frame because this
8919 could be the shell widget window
8920 if the frame has no title bar. */
8921 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
8923 /* Not quite sure this is needed -pd */
8924 if (f
&& FRAME_XIC (f
))
8925 XSetICFocus (FRAME_XIC (f
));
8927 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
8928 instructs the WM to set the input focus automatically for
8929 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
8930 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
8931 it has set the focus. So, XSetInputFocus below is not
8934 The call to XSetInputFocus below has also caused trouble. In
8935 cases where the XSetInputFocus done by the WM and the one
8936 below are temporally close (on a fast machine), the call
8937 below can generate additional FocusIn events which confuse
8940 /* Since we set WM_TAKE_FOCUS, we must call
8941 XSetInputFocus explicitly. But not if f is null,
8942 since that might be an event for a deleted frame. */
8945 Display
*d
= event
.xclient
.display
;
8946 /* Catch and ignore errors, in case window has been
8947 iconified by a window manager such as GWM. */
8948 int count
= x_catch_errors (d
);
8949 XSetInputFocus (d
, event
.xclient
.window
,
8950 /* The ICCCM says this is
8951 the only valid choice. */
8953 event
.xclient
.data
.l
[1]);
8954 /* This is needed to detect the error
8955 if there is an error. */
8957 x_uncatch_errors (d
, count
);
8959 /* Not certain about handling scroll bars here */
8962 else if (event
.xclient
.data
.l
[0]
8963 == dpyinfo
->Xatom_wm_save_yourself
)
8965 /* Save state modify the WM_COMMAND property to
8966 something which can reinstate us. This notifies
8967 the session manager, who's looking for such a
8968 PropertyNotify. Can restart processing when
8969 a keyboard or mouse event arrives. */
8972 f
= x_top_window_to_frame (dpyinfo
,
8973 event
.xclient
.window
);
8975 /* This is just so we only give real data once
8976 for a single Emacs process. */
8977 if (f
== SELECTED_FRAME ())
8978 XSetCommand (FRAME_X_DISPLAY (f
),
8979 event
.xclient
.window
,
8980 initial_argv
, initial_argc
);
8982 XSetCommand (FRAME_X_DISPLAY (f
),
8983 event
.xclient
.window
,
8987 else if (event
.xclient
.data
.l
[0]
8988 == dpyinfo
->Xatom_wm_delete_window
)
8991 = x_any_window_to_frame (dpyinfo
,
8992 event
.xclient
.window
);
8999 bufp
->kind
= delete_window_event
;
9000 XSETFRAME (bufp
->frame_or_window
, f
);
9008 else if (event
.xclient
.message_type
9009 == dpyinfo
->Xatom_wm_configure_denied
)
9012 else if (event
.xclient
.message_type
9013 == dpyinfo
->Xatom_wm_window_moved
)
9017 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9019 new_x
= event
.xclient
.data
.s
[0];
9020 new_y
= event
.xclient
.data
.s
[1];
9024 f
->output_data
.x
->left_pos
= new_x
;
9025 f
->output_data
.x
->top_pos
= new_y
;
9029 else if (event
.xclient
.message_type
9030 == dpyinfo
->Xatom_editres
)
9033 = x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
9034 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
9037 #endif /* HACK_EDITRES */
9038 else if ((event
.xclient
.message_type
9039 == dpyinfo
->Xatom_DONE
)
9040 || (event
.xclient
.message_type
9041 == dpyinfo
->Xatom_PAGE
))
9043 /* Ghostview job completed. Kill it. We could
9044 reply with "Next" if we received "Page", but we
9045 currently never do because we are interested in
9046 images, only, which should have 1 page. */
9047 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
9049 = x_window_to_frame (dpyinfo
, event
.xclient
.window
);
9050 x_kill_gs_process (pixmap
, f
);
9051 expose_frame (f
, 0, 0, 0, 0);
9053 #ifdef USE_TOOLKIT_SCROLL_BARS
9054 /* Scroll bar callbacks send a ClientMessage from which
9055 we construct an input_event. */
9056 else if (event
.xclient
.message_type
9057 == dpyinfo
->Xatom_Scrollbar
)
9059 x_scroll_bar_to_input_event (&event
, bufp
);
9060 ++bufp
, ++count
, --numchars
;
9063 #endif /* USE_TOOLKIT_SCROLL_BARS */
9069 case SelectionNotify
:
9070 #ifdef USE_X_TOOLKIT
9071 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
9073 #endif /* not USE_X_TOOLKIT */
9074 x_handle_selection_notify (&event
.xselection
);
9077 case SelectionClear
: /* Someone has grabbed ownership. */
9078 #ifdef USE_X_TOOLKIT
9079 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
9081 #endif /* USE_X_TOOLKIT */
9083 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
9088 bufp
->kind
= selection_clear_event
;
9089 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
9090 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
9091 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
9092 bufp
->frame_or_window
= Qnil
;
9100 case SelectionRequest
: /* Someone wants our selection. */
9101 #ifdef USE_X_TOOLKIT
9102 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
9104 #endif /* USE_X_TOOLKIT */
9105 if (x_queue_selection_requests
)
9106 x_queue_event (x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
),
9110 XSelectionRequestEvent
*eventp
= (XSelectionRequestEvent
*) &event
;
9115 bufp
->kind
= selection_request_event
;
9116 SELECTION_EVENT_DISPLAY (bufp
) = eventp
->display
;
9117 SELECTION_EVENT_REQUESTOR (bufp
) = eventp
->requestor
;
9118 SELECTION_EVENT_SELECTION (bufp
) = eventp
->selection
;
9119 SELECTION_EVENT_TARGET (bufp
) = eventp
->target
;
9120 SELECTION_EVENT_PROPERTY (bufp
) = eventp
->property
;
9121 SELECTION_EVENT_TIME (bufp
) = eventp
->time
;
9122 bufp
->frame_or_window
= Qnil
;
9130 case PropertyNotify
:
9131 #ifdef USE_X_TOOLKIT
9132 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
9134 #endif /* not USE_X_TOOLKIT */
9135 x_handle_property_notify (&event
.xproperty
);
9138 case ReparentNotify
:
9139 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
9143 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
9144 x_real_positions (f
, &x
, &y
);
9145 f
->output_data
.x
->left_pos
= x
;
9146 f
->output_data
.x
->top_pos
= y
;
9151 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
9154 if (f
->async_visible
== 0)
9156 f
->async_visible
= 1;
9157 f
->async_iconified
= 0;
9158 f
->output_data
.x
->has_been_visible
= 1;
9159 SET_FRAME_GARBAGED (f
);
9162 expose_frame (x_window_to_frame (dpyinfo
,
9163 event
.xexpose
.window
),
9164 event
.xexpose
.x
, event
.xexpose
.y
,
9165 event
.xexpose
.width
, event
.xexpose
.height
);
9169 #ifdef USE_TOOLKIT_SCROLL_BARS
9170 /* Dispatch event to the widget. */
9172 #else /* not USE_TOOLKIT_SCROLL_BARS */
9173 struct scroll_bar
*bar
9174 = x_window_to_scroll_bar (event
.xexpose
.window
);
9177 x_scroll_bar_expose (bar
, &event
);
9178 #ifdef USE_X_TOOLKIT
9181 #endif /* USE_X_TOOLKIT */
9182 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9186 case GraphicsExpose
: /* This occurs when an XCopyArea's
9187 source area was obscured or not
9189 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
9193 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
9194 event
.xgraphicsexpose
.width
,
9195 event
.xgraphicsexpose
.height
);
9197 #ifdef USE_X_TOOLKIT
9200 #endif /* USE_X_TOOLKIT */
9203 case NoExpose
: /* This occurs when an XCopyArea's
9204 source area was completely
9209 /* Redo the mouse-highlight after the tooltip has gone. */
9210 if (event
.xmap
.window
== tip_window
)
9213 redo_mouse_highlight ();
9216 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
9217 if (f
) /* F may no longer exist if
9218 the frame was deleted. */
9220 /* While a frame is unmapped, display generation is
9221 disabled; you don't want to spend time updating a
9222 display that won't ever be seen. */
9223 f
->async_visible
= 0;
9224 /* We can't distinguish, from the event, whether the window
9225 has become iconified or invisible. So assume, if it
9226 was previously visible, than now it is iconified.
9227 But x_make_frame_invisible clears both
9228 the visible flag and the iconified flag;
9229 and that way, we know the window is not iconified now. */
9230 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
9232 f
->async_iconified
= 1;
9234 bufp
->kind
= iconify_event
;
9235 XSETFRAME (bufp
->frame_or_window
, f
);
9244 if (event
.xmap
.window
== tip_window
)
9245 /* The tooltip has been drawn already. Avoid
9246 the SET_FRAME_GARBAGED below. */
9249 /* We use x_top_window_to_frame because map events can
9250 come for sub-windows and they don't mean that the
9251 frame is visible. */
9252 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
9255 f
->async_visible
= 1;
9256 f
->async_iconified
= 0;
9257 f
->output_data
.x
->has_been_visible
= 1;
9259 /* wait_reading_process_input will notice this and update
9260 the frame's display structures. */
9261 SET_FRAME_GARBAGED (f
);
9265 bufp
->kind
= deiconify_event
;
9266 XSETFRAME (bufp
->frame_or_window
, f
);
9271 else if (! NILP (Vframe_list
)
9272 && ! NILP (XCDR (Vframe_list
)))
9273 /* Force a redisplay sooner or later
9274 to update the frame titles
9275 in case this is the second frame. */
9276 record_asynch_buffer_change ();
9281 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
9284 /* I couldn't find a way to prevent LessTif scroll bars
9285 from consuming key events. */
9288 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
9290 if (widget
&& XmIsScrollBar (widget
))
9292 widget
= XtParent (widget
);
9293 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
9296 #endif /* USE_MOTIF */
9300 KeySym keysym
, orig_keysym
;
9301 /* al%imercury@uunet.uu.net says that making this 81 instead of
9302 80 fixed a bug whereby meta chars made his Emacs hang. */
9303 unsigned char copy_buffer
[81];
9307 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
9308 extra_keyboard_modifiers
);
9309 modifiers
= event
.xkey
.state
;
9311 /* This will have to go some day... */
9313 /* make_lispy_event turns chars into control chars.
9314 Don't do it here because XLookupString is too eager. */
9315 event
.xkey
.state
&= ~ControlMask
;
9316 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
9317 | dpyinfo
->super_mod_mask
9318 | dpyinfo
->hyper_mod_mask
9319 | dpyinfo
->alt_mod_mask
);
9321 /* In case Meta is ComposeCharacter,
9322 clear its status. According to Markus Ehrnsperger
9323 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
9324 this enables ComposeCharacter to work whether or
9325 not it is combined with Meta. */
9326 if (modifiers
& dpyinfo
->meta_mod_mask
)
9327 bzero (&compose_status
, sizeof (compose_status
));
9332 unsigned char *copy_bufptr
= copy_buffer
;
9333 int copy_bufsiz
= sizeof (copy_buffer
);
9334 Status status_return
;
9336 nbytes
= XmbLookupString (FRAME_XIC (f
),
9337 &event
.xkey
, copy_bufptr
,
9338 copy_bufsiz
, &keysym
,
9340 if (status_return
== XBufferOverflow
)
9342 copy_bufsiz
= nbytes
+ 1;
9343 copy_bufptr
= (char *) alloca (copy_bufsiz
);
9344 nbytes
= XmbLookupString (FRAME_XIC (f
),
9345 &event
.xkey
, copy_bufptr
,
9346 copy_bufsiz
, &keysym
,
9350 if (status_return
== XLookupNone
)
9352 else if (status_return
== XLookupChars
)
9354 else if (status_return
!= XLookupKeySym
9355 && status_return
!= XLookupBoth
)
9359 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
9360 80, &keysym
, &compose_status
);
9362 nbytes
= XLookupString (&event
.xkey
, copy_buffer
,
9363 80, &keysym
, &compose_status
);
9366 orig_keysym
= keysym
;
9370 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
9371 || keysym
== XK_Delete
9372 #ifdef XK_ISO_Left_Tab
9373 || (keysym
>= XK_ISO_Left_Tab
&& keysym
<= XK_ISO_Enter
)
9375 || (keysym
>= XK_Kanji
&& keysym
<= XK_Eisu_toggle
)
9376 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
9377 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
9379 /* This recognizes the "extended function keys".
9380 It seems there's no cleaner way.
9381 Test IsModifierKey to avoid handling mode_switch
9383 || ((unsigned) (keysym
) >= XK_Select
9384 && (unsigned)(keysym
) < XK_KP_Space
)
9386 #ifdef XK_dead_circumflex
9387 || orig_keysym
== XK_dead_circumflex
9389 #ifdef XK_dead_grave
9390 || orig_keysym
== XK_dead_grave
9392 #ifdef XK_dead_tilde
9393 || orig_keysym
== XK_dead_tilde
9395 #ifdef XK_dead_diaeresis
9396 || orig_keysym
== XK_dead_diaeresis
9398 #ifdef XK_dead_macron
9399 || orig_keysym
== XK_dead_macron
9401 #ifdef XK_dead_degree
9402 || orig_keysym
== XK_dead_degree
9404 #ifdef XK_dead_acute
9405 || orig_keysym
== XK_dead_acute
9407 #ifdef XK_dead_cedilla
9408 || orig_keysym
== XK_dead_cedilla
9410 #ifdef XK_dead_breve
9411 || orig_keysym
== XK_dead_breve
9413 #ifdef XK_dead_ogonek
9414 || orig_keysym
== XK_dead_ogonek
9416 #ifdef XK_dead_caron
9417 || orig_keysym
== XK_dead_caron
9419 #ifdef XK_dead_doubleacute
9420 || orig_keysym
== XK_dead_doubleacute
9422 #ifdef XK_dead_abovedot
9423 || orig_keysym
== XK_dead_abovedot
9425 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
9426 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
9427 /* Any "vendor-specific" key is ok. */
9428 || (orig_keysym
& (1 << 28)))
9429 && ! (IsModifierKey (orig_keysym
)
9431 #ifdef XK_Mode_switch
9432 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
9435 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
9437 #endif /* not HAVE_X11R5 */
9440 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
9442 temp_buffer
[temp_index
++] = keysym
;
9443 bufp
->kind
= non_ascii_keystroke
;
9444 bufp
->code
= keysym
;
9445 XSETFRAME (bufp
->frame_or_window
, f
);
9447 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
9449 bufp
->timestamp
= event
.xkey
.time
;
9454 else if (numchars
> nbytes
)
9458 for (i
= 0; i
< nbytes
; i
++)
9460 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
9462 temp_buffer
[temp_index
++] = copy_buffer
[i
];
9463 bufp
->kind
= ascii_keystroke
;
9464 bufp
->code
= copy_buffer
[i
];
9465 XSETFRAME (bufp
->frame_or_window
, f
);
9467 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
9469 bufp
->timestamp
= event
.xkey
.time
;
9476 if (keysym
== NoSymbol
)
9486 /* Don't dispatch this event since XtDispatchEvent calls
9487 XFilterEvent, and two calls in a row may freeze the
9496 /* Don't dispatch this event since XtDispatchEvent calls
9497 XFilterEvent, and two calls in a row may freeze the
9504 /* Here's a possible interpretation of the whole
9505 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If
9506 you get a FocusIn event, you have to get a FocusOut
9507 event before you relinquish the focus. If you
9508 haven't received a FocusIn event, then a mere
9509 LeaveNotify is enough to free you. */
9513 int from_menu_bar_p
= 0;
9515 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
9517 #ifdef LESSTIF_VERSION
9518 /* When clicking outside of a menu bar popup to close
9519 it, we get a FocusIn/ EnterNotify sequence of
9520 events. The flag event.xcrossing.focus is not set
9521 in the EnterNotify event of that sequence because
9522 the focus is in the menu bar,
9523 event.xcrossing.window is the frame's X window.
9524 Unconditionally setting the focus frame to null in
9525 this case is not the right thing, because no event
9526 follows that could set the focus frame to the right
9529 This could be a LessTif bug, but I wasn't able to
9530 reproduce the behavior in a simple test program.
9532 (gerd, LessTif 0.88.1). */
9534 if (!event
.xcrossing
.focus
9536 && f
->output_data
.x
->menubar_widget
)
9541 XGetInputFocus (FRAME_X_DISPLAY (f
), &focus
, &revert
);
9542 if (focus
== XtWindow (f
->output_data
.x
->menubar_widget
))
9543 from_menu_bar_p
= 1;
9545 #endif /* LESSTIF_VERSION */
9547 if (event
.xcrossing
.focus
|| from_menu_bar_p
)
9549 /* Avoid nasty pop/raise loops. */
9550 if (f
&& (!(f
->auto_raise
)
9552 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
9554 x_new_focus_frame (dpyinfo
, f
);
9555 enter_timestamp
= event
.xcrossing
.time
;
9558 else if (f
== dpyinfo
->x_focus_frame
)
9559 x_new_focus_frame (dpyinfo
, 0);
9561 /* EnterNotify counts as mouse movement,
9562 so update things that depend on mouse position. */
9563 if (f
&& !f
->output_data
.x
->busy_p
)
9564 note_mouse_movement (f
, &event
.xmotion
);
9569 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
9570 if (event
.xfocus
.detail
!= NotifyPointer
)
9571 dpyinfo
->x_focus_event_frame
= f
;
9573 x_new_focus_frame (dpyinfo
, f
);
9576 if (f
&& FRAME_XIC (f
))
9577 XSetICFocus (FRAME_XIC (f
));
9583 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
9587 int from_menu_bar_p
= 0;
9589 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9591 /* If we move outside the frame, then we're
9592 certainly no longer on any text in the frame. */
9593 clear_mouse_face (dpyinfo
);
9594 dpyinfo
->mouse_face_mouse_frame
= 0;
9597 /* Generate a nil HELP_EVENT to cancel a help-echo.
9598 Do it only if there's something to cancel.
9599 Otherwise, the startup message is cleared when
9600 the mouse leaves the frame. */
9601 if (any_help_event_p
)
9603 XSETFRAME (frame
, f
);
9604 bufp
->kind
= HELP_EVENT
;
9605 bufp
->frame_or_window
= Fcons (frame
, Qnil
);
9606 ++bufp
, ++count
, --numchars
;
9609 #ifdef LESSTIF_VERSION
9610 /* Please see the comment at the start of the
9611 EnterNotify case. */
9612 if (!event
.xcrossing
.focus
9613 && f
->output_data
.x
->menubar_widget
)
9617 XGetInputFocus (FRAME_X_DISPLAY (f
), &focus
, &revert
);
9618 if (focus
== XtWindow (f
->output_data
.x
->menubar_widget
))
9619 from_menu_bar_p
= 1;
9621 #endif /* LESSTIF_VERSION */
9623 if (event
.xcrossing
.focus
|| from_menu_bar_p
)
9624 x_mouse_leave (dpyinfo
);
9627 if (f
== dpyinfo
->x_focus_event_frame
)
9628 dpyinfo
->x_focus_event_frame
= 0;
9629 if (f
== dpyinfo
->x_focus_frame
)
9630 x_new_focus_frame (dpyinfo
, 0);
9636 f
= x_any_window_to_frame (dpyinfo
, event
.xfocus
.window
);
9637 if (event
.xfocus
.detail
!= NotifyPointer
9638 && f
== dpyinfo
->x_focus_event_frame
)
9639 dpyinfo
->x_focus_event_frame
= 0;
9640 if (f
&& f
== dpyinfo
->x_focus_frame
)
9641 x_new_focus_frame (dpyinfo
, 0);
9644 if (f
&& FRAME_XIC (f
))
9645 XUnsetICFocus (FRAME_XIC (f
));
9652 previous_help_echo
= help_echo
;
9655 if (dpyinfo
->grabbed
&& last_mouse_frame
9656 && FRAME_LIVE_P (last_mouse_frame
))
9657 f
= last_mouse_frame
;
9659 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
9662 note_mouse_movement (f
, &event
.xmotion
);
9665 #ifndef USE_TOOLKIT_SCROLL_BARS
9666 struct scroll_bar
*bar
9667 = x_window_to_scroll_bar (event
.xmotion
.window
);
9670 x_scroll_bar_note_movement (bar
, &event
);
9671 #endif /* USE_TOOLKIT_SCROLL_BARS */
9673 /* If we move outside the frame, then we're
9674 certainly no longer on any text in the frame. */
9675 clear_mouse_face (dpyinfo
);
9678 /* If the contents of the global variable help_echo
9679 has changed, generate a HELP_EVENT. */
9680 if (STRINGP (help_echo
)
9681 || STRINGP (previous_help_echo
))
9686 XSETFRAME (frame
, f
);
9690 any_help_event_p
= 1;
9691 bufp
->kind
= HELP_EVENT
;
9692 bufp
->frame_or_window
= Fcons (frame
, help_echo
);
9693 ++bufp
, ++count
, --numchars
;
9699 case ConfigureNotify
:
9700 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
9703 #ifndef USE_X_TOOLKIT
9704 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, event
.xconfigure
.height
);
9705 int columns
= PIXEL_TO_CHAR_WIDTH (f
, event
.xconfigure
.width
);
9707 /* In the toolkit version, change_frame_size
9708 is called by the code that handles resizing
9709 of the EmacsFrame widget. */
9711 /* Even if the number of character rows and columns has
9712 not changed, the font size may have changed, so we need
9713 to check the pixel dimensions as well. */
9714 if (columns
!= f
->width
9715 || rows
!= f
->height
9716 || event
.xconfigure
.width
!= f
->output_data
.x
->pixel_width
9717 || event
.xconfigure
.height
!= f
->output_data
.x
->pixel_height
)
9719 change_frame_size (f
, rows
, columns
, 0, 1, 0);
9720 SET_FRAME_GARBAGED (f
);
9721 cancel_mouse_face (f
);
9725 f
->output_data
.x
->pixel_width
= event
.xconfigure
.width
;
9726 f
->output_data
.x
->pixel_height
= event
.xconfigure
.height
;
9728 /* What we have now is the position of Emacs's own window.
9729 Convert that to the position of the window manager window. */
9730 x_real_positions (f
, &f
->output_data
.x
->left_pos
,
9731 &f
->output_data
.x
->top_pos
);
9734 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
9735 xic_set_statusarea (f
);
9738 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
9740 /* Since the WM decorations come below top_pos now,
9741 we must put them below top_pos in the future. */
9742 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
9743 x_wm_set_size_hint (f
, (long) 0, 0);
9746 /* Some window managers pass (0,0) as the location of
9747 the window, and the Motif event handler stores it
9748 in the emacs widget, which messes up Motif menus. */
9749 if (event
.xconfigure
.x
== 0 && event
.xconfigure
.y
== 0)
9751 event
.xconfigure
.x
= f
->output_data
.x
->widget
->core
.x
;
9752 event
.xconfigure
.y
= f
->output_data
.x
->widget
->core
.y
;
9754 #endif /* USE_MOTIF */
9761 /* If we decide we want to generate an event to be seen
9762 by the rest of Emacs, we put it here. */
9763 struct input_event emacs_event
;
9766 emacs_event
.kind
= no_event
;
9767 bzero (&compose_status
, sizeof (compose_status
));
9769 if (dpyinfo
->grabbed
9771 && FRAME_LIVE_P (last_mouse_frame
))
9772 f
= last_mouse_frame
;
9774 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
9778 /* Is this in the tool-bar? */
9779 if (WINDOWP (f
->tool_bar_window
)
9780 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
9785 x
= event
.xbutton
.x
;
9786 y
= event
.xbutton
.y
;
9789 window
= window_from_coordinates (f
, x
, y
, &p
, 1);
9790 if (EQ (window
, f
->tool_bar_window
))
9792 x_handle_tool_bar_click (f
, &event
.xbutton
);
9798 if (!dpyinfo
->x_focus_frame
9799 || f
== dpyinfo
->x_focus_frame
)
9800 construct_mouse_click (&emacs_event
, &event
, f
);
9804 #ifndef USE_TOOLKIT_SCROLL_BARS
9805 struct scroll_bar
*bar
9806 = x_window_to_scroll_bar (event
.xbutton
.window
);
9809 x_scroll_bar_handle_click (bar
, &event
, &emacs_event
);
9810 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9813 if (event
.type
== ButtonPress
)
9815 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
9816 last_mouse_frame
= f
;
9817 /* Ignore any mouse motion that happened
9818 before this event; any subsequent mouse-movement
9819 Emacs events should reflect only motion after
9825 last_tool_bar_item
= -1;
9829 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
9832 if (numchars
>= 1 && emacs_event
.kind
!= no_event
)
9834 bcopy (&emacs_event
, bufp
, sizeof (struct input_event
));
9840 #ifdef USE_X_TOOLKIT
9841 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
9842 /* For a down-event in the menu bar,
9843 don't pass it to Xt right now.
9844 Instead, save it away
9845 and we will pass it to Xt from kbd_buffer_get_event.
9846 That way, we can run some Lisp code first. */
9847 if (f
&& event
.type
== ButtonPress
9848 /* Verify the event is really within the menu bar
9849 and not just sent to it due to grabbing. */
9850 && event
.xbutton
.x
>= 0
9851 && event
.xbutton
.x
< f
->output_data
.x
->pixel_width
9852 && event
.xbutton
.y
>= 0
9853 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
9854 && event
.xbutton
.same_screen
)
9856 SET_SAVED_BUTTON_EVENT
;
9857 XSETFRAME (last_mouse_press_frame
, f
);
9859 else if (event
.type
== ButtonPress
)
9861 last_mouse_press_frame
= Qnil
;
9865 #ifdef USE_MOTIF /* This should do not harm for Lucid,
9866 but I am trying to be cautious. */
9867 else if (event
.type
== ButtonRelease
)
9869 if (!NILP (last_mouse_press_frame
))
9871 f
= XFRAME (last_mouse_press_frame
);
9872 if (f
->output_data
.x
)
9873 SET_SAVED_BUTTON_EVENT
;
9878 #endif /* USE_MOTIF */
9881 #endif /* USE_X_TOOLKIT */
9885 case CirculateNotify
:
9888 case CirculateRequest
:
9891 case VisibilityNotify
:
9895 /* Someone has changed the keyboard mapping - update the
9897 switch (event
.xmapping
.request
)
9899 case MappingModifier
:
9900 x_find_modifier_meanings (dpyinfo
);
9901 /* This is meant to fall through. */
9902 case MappingKeyboard
:
9903 XRefreshKeyboardMapping (&event
.xmapping
);
9909 #ifdef USE_X_TOOLKIT
9911 XtDispatchEvent (&event
);
9913 #endif /* USE_X_TOOLKIT */
9921 /* On some systems, an X bug causes Emacs to get no more events
9922 when the window is destroyed. Detect that. (1994.) */
9925 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
9926 One XNOOP in 100 loops will make Emacs terminate.
9927 B. Bretthauer, 1994 */
9929 if (x_noop_count
>= 100)
9933 if (next_noop_dpyinfo
== 0)
9934 next_noop_dpyinfo
= x_display_list
;
9936 XNoOp (next_noop_dpyinfo
->display
);
9938 /* Each time we get here, cycle through the displays now open. */
9939 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
9943 /* If the focus was just given to an auto-raising frame,
9945 /* ??? This ought to be able to handle more than one such frame. */
9946 if (pending_autoraise_frame
)
9948 x_raise_frame (pending_autoraise_frame
);
9949 pending_autoraise_frame
= 0;
9959 /***********************************************************************
9961 ***********************************************************************/
9963 /* Note if the text cursor of window W has been overwritten by a
9964 drawing operation that outputs N glyphs starting at HPOS in the
9965 line given by output_cursor.vpos. N < 0 means all the rest of the
9966 line after HPOS has been written. */
9969 note_overwritten_text_cursor (w
, hpos
, n
)
9973 if (updated_area
== TEXT_AREA
9974 && output_cursor
.vpos
== w
->phys_cursor
.vpos
9975 && hpos
<= w
->phys_cursor
.hpos
9977 || hpos
+ n
> w
->phys_cursor
.hpos
))
9978 w
->phys_cursor_on_p
= 0;
9982 /* Set clipping for output in glyph row ROW. W is the window in which
9983 we operate. GC is the graphics context to set clipping in.
9984 WHOLE_LINE_P non-zero means include the areas used for truncation
9985 mark display and alike in the clipping rectangle.
9987 ROW may be a text row or, e.g., a mode line. Text rows must be
9988 clipped to the interior of the window dedicated to text display,
9989 mode lines must be clipped to the whole window. */
9992 x_clip_to_row (w
, row
, gc
, whole_line_p
)
9994 struct glyph_row
*row
;
9998 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
9999 XRectangle clip_rect
;
10000 int window_x
, window_y
, window_width
, window_height
;
10002 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
10004 clip_rect
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
10005 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
10006 clip_rect
.y
= max (clip_rect
.y
, window_y
);
10007 clip_rect
.width
= window_width
;
10008 clip_rect
.height
= row
->visible_height
;
10010 /* If clipping to the whole line, including trunc marks, extend
10011 the rectangle to the left and increase its width. */
10014 clip_rect
.x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
10015 clip_rect
.width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
10018 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
10022 /* Draw a hollow box cursor on window W in glyph row ROW. */
10025 x_draw_hollow_cursor (w
, row
)
10027 struct glyph_row
*row
;
10029 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10030 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10031 Display
*dpy
= FRAME_X_DISPLAY (f
);
10034 struct glyph
*cursor_glyph
;
10037 /* Compute frame-relative coordinates from window-relative
10039 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
10040 y
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
10041 + row
->ascent
- w
->phys_cursor_ascent
);
10042 h
= row
->height
- 1;
10044 /* Get the glyph the cursor is on. If we can't tell because
10045 the current matrix is invalid or such, give up. */
10046 cursor_glyph
= get_phys_cursor_glyph (w
);
10047 if (cursor_glyph
== NULL
)
10050 /* Compute the width of the rectangle to draw. If on a stretch
10051 glyph, and `x-stretch-block-cursor' is nil, don't draw a
10052 rectangle as wide as the glyph, but use a canonical character
10054 wd
= cursor_glyph
->pixel_width
- 1;
10055 if (cursor_glyph
->type
== STRETCH_GLYPH
10056 && !x_stretch_cursor_p
)
10057 wd
= min (CANON_X_UNIT (f
), wd
);
10059 /* The foreground of cursor_gc is typically the same as the normal
10060 background color, which can cause the cursor box to be invisible. */
10061 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
10062 if (dpyinfo
->scratch_cursor_gc
)
10063 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
10065 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
10066 GCForeground
, &xgcv
);
10067 gc
= dpyinfo
->scratch_cursor_gc
;
10069 /* Set clipping, draw the rectangle, and reset clipping again. */
10070 x_clip_to_row (w
, row
, gc
, 0);
10071 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
10072 XSetClipMask (dpy
, gc
, None
);
10076 /* Draw a bar cursor on window W in glyph row ROW.
10078 Implementation note: One would like to draw a bar cursor with an
10079 angle equal to the one given by the font property XA_ITALIC_ANGLE.
10080 Unfortunately, I didn't find a font yet that has this property set.
10084 x_draw_bar_cursor (w
, row
, width
)
10086 struct glyph_row
*row
;
10089 /* If cursor hpos is out of bounds, don't draw garbage. This can
10090 happen in mini-buffer windows when switching between echo area
10091 glyphs and mini-buffer. */
10092 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
10094 struct frame
*f
= XFRAME (w
->frame
);
10095 struct glyph
*cursor_glyph
;
10098 unsigned long mask
;
10103 cursor_glyph
= get_phys_cursor_glyph (w
);
10104 if (cursor_glyph
== NULL
)
10107 xgcv
.background
= f
->output_data
.x
->cursor_pixel
;
10108 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
10109 xgcv
.graphics_exposures
= 0;
10110 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
10111 dpy
= FRAME_X_DISPLAY (f
);
10112 window
= FRAME_X_WINDOW (f
);
10113 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
10116 XChangeGC (dpy
, gc
, mask
, &xgcv
);
10119 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
10120 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
10124 width
= f
->output_data
.x
->cursor_width
;
10126 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
10127 x_clip_to_row (w
, row
, gc
, 0);
10128 XFillRectangle (dpy
, window
, gc
,
10130 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
10131 min (cursor_glyph
->pixel_width
, width
),
10133 XSetClipMask (dpy
, gc
, None
);
10138 /* Clear the cursor of window W to background color, and mark the
10139 cursor as not shown. This is used when the text where the cursor
10140 is is about to be rewritten. */
10146 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
10147 x_update_window_cursor (w
, 0);
10151 /* Draw the cursor glyph of window W in glyph row ROW. See the
10152 comment of x_draw_glyphs for the meaning of HL. */
10155 x_draw_phys_cursor_glyph (w
, row
, hl
)
10157 struct glyph_row
*row
;
10158 enum draw_glyphs_face hl
;
10160 /* If cursor hpos is out of bounds, don't draw garbage. This can
10161 happen in mini-buffer windows when switching between echo area
10162 glyphs and mini-buffer. */
10163 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
10165 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
10166 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
10169 /* When we erase the cursor, and ROW is overlapped by other
10170 rows, make sure that these overlapping parts of other rows
10172 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
10174 if (row
> w
->current_matrix
->rows
10175 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
10176 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
10178 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
10179 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
10180 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
10186 /* Erase the image of a cursor of window W from the screen. */
10189 x_erase_phys_cursor (w
)
10192 struct frame
*f
= XFRAME (w
->frame
);
10193 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10194 int hpos
= w
->phys_cursor
.hpos
;
10195 int vpos
= w
->phys_cursor
.vpos
;
10196 int mouse_face_here_p
= 0;
10197 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
10198 struct glyph_row
*cursor_row
;
10199 struct glyph
*cursor_glyph
;
10200 enum draw_glyphs_face hl
;
10202 /* No cursor displayed or row invalidated => nothing to do on the
10204 if (w
->phys_cursor_type
== NO_CURSOR
)
10205 goto mark_cursor_off
;
10207 /* VPOS >= active_glyphs->nrows means that window has been resized.
10208 Don't bother to erase the cursor. */
10209 if (vpos
>= active_glyphs
->nrows
)
10210 goto mark_cursor_off
;
10212 /* If row containing cursor is marked invalid, there is nothing we
10214 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
10215 if (!cursor_row
->enabled_p
)
10216 goto mark_cursor_off
;
10218 /* This can happen when the new row is shorter than the old one.
10219 In this case, either x_draw_glyphs or clear_end_of_line
10220 should have cleared the cursor. Note that we wouldn't be
10221 able to erase the cursor in this case because we don't have a
10222 cursor glyph at hand. */
10223 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
10224 goto mark_cursor_off
;
10226 /* If the cursor is in the mouse face area, redisplay that when
10227 we clear the cursor. */
10228 if (w
== XWINDOW (dpyinfo
->mouse_face_window
)
10229 && (vpos
> dpyinfo
->mouse_face_beg_row
10230 || (vpos
== dpyinfo
->mouse_face_beg_row
10231 && hpos
>= dpyinfo
->mouse_face_beg_col
))
10232 && (vpos
< dpyinfo
->mouse_face_end_row
10233 || (vpos
== dpyinfo
->mouse_face_end_row
10234 && hpos
< dpyinfo
->mouse_face_end_col
))
10235 /* Don't redraw the cursor's spot in mouse face if it is at the
10236 end of a line (on a newline). The cursor appears there, but
10237 mouse highlighting does not. */
10238 && cursor_row
->used
[TEXT_AREA
] > hpos
)
10239 mouse_face_here_p
= 1;
10241 /* Maybe clear the display under the cursor. */
10242 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
10245 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
10247 cursor_glyph
= get_phys_cursor_glyph (w
);
10248 if (cursor_glyph
== NULL
)
10249 goto mark_cursor_off
;
10251 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
10253 XClearArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10255 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
10257 cursor_glyph
->pixel_width
,
10258 cursor_row
->visible_height
,
10262 /* Erase the cursor by redrawing the character underneath it. */
10263 if (mouse_face_here_p
)
10264 hl
= DRAW_MOUSE_FACE
;
10265 else if (cursor_row
->inverse_p
)
10266 hl
= DRAW_INVERSE_VIDEO
;
10268 hl
= DRAW_NORMAL_TEXT
;
10269 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
10272 w
->phys_cursor_on_p
= 0;
10273 w
->phys_cursor_type
= NO_CURSOR
;
10277 /* Display or clear cursor of window W. If ON is zero, clear the
10278 cursor. If it is non-zero, display the cursor. If ON is nonzero,
10279 where to put the cursor is specified by HPOS, VPOS, X and Y. */
10282 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
10284 int on
, hpos
, vpos
, x
, y
;
10286 struct frame
*f
= XFRAME (w
->frame
);
10287 int new_cursor_type
;
10288 int new_cursor_width
;
10289 struct glyph_matrix
*current_glyphs
;
10290 struct glyph_row
*glyph_row
;
10291 struct glyph
*glyph
;
10293 /* This is pointless on invisible frames, and dangerous on garbaged
10294 windows and frames; in the latter case, the frame or window may
10295 be in the midst of changing its size, and x and y may be off the
10297 if (! FRAME_VISIBLE_P (f
)
10298 || FRAME_GARBAGED_P (f
)
10299 || vpos
>= w
->current_matrix
->nrows
10300 || hpos
>= w
->current_matrix
->matrix_w
)
10303 /* If cursor is off and we want it off, return quickly. */
10304 if (!on
&& !w
->phys_cursor_on_p
)
10307 current_glyphs
= w
->current_matrix
;
10308 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
10309 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
10311 /* If cursor row is not enabled, we don't really know where to
10312 display the cursor. */
10313 if (!glyph_row
->enabled_p
)
10315 w
->phys_cursor_on_p
= 0;
10319 xassert (interrupt_input_blocked
);
10321 /* Set new_cursor_type to the cursor we want to be displayed. In a
10322 mini-buffer window, we want the cursor only to appear if we are
10323 reading input from this window. For the selected window, we want
10324 the cursor type given by the frame parameter. If explicitly
10325 marked off, draw no cursor. In all other cases, we want a hollow
10327 new_cursor_width
= -1;
10328 if (cursor_in_echo_area
10329 && FRAME_HAS_MINIBUF_P (f
)
10330 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
10332 if (w
== XWINDOW (echo_area_window
))
10333 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
10335 new_cursor_type
= HOLLOW_BOX_CURSOR
;
10339 if (w
!= XWINDOW (selected_window
)
10340 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
10342 extern int cursor_in_non_selected_windows
;
10344 if (MINI_WINDOW_P (w
) || !cursor_in_non_selected_windows
)
10345 new_cursor_type
= NO_CURSOR
;
10347 new_cursor_type
= HOLLOW_BOX_CURSOR
;
10349 else if (w
->cursor_off_p
)
10350 new_cursor_type
= NO_CURSOR
;
10353 struct buffer
*b
= XBUFFER (w
->buffer
);
10355 if (EQ (b
->cursor_type
, Qt
))
10356 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
10358 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
10359 &new_cursor_width
);
10363 /* If cursor is currently being shown and we don't want it to be or
10364 it is in the wrong place, or the cursor type is not what we want,
10366 if (w
->phys_cursor_on_p
10368 || w
->phys_cursor
.x
!= x
10369 || w
->phys_cursor
.y
!= y
10370 || new_cursor_type
!= w
->phys_cursor_type
))
10371 x_erase_phys_cursor (w
);
10373 /* If the cursor is now invisible and we want it to be visible,
10375 if (on
&& !w
->phys_cursor_on_p
)
10377 w
->phys_cursor_ascent
= glyph_row
->ascent
;
10378 w
->phys_cursor_height
= glyph_row
->height
;
10380 /* Set phys_cursor_.* before x_draw_.* is called because some
10381 of them may need the information. */
10382 w
->phys_cursor
.x
= x
;
10383 w
->phys_cursor
.y
= glyph_row
->y
;
10384 w
->phys_cursor
.hpos
= hpos
;
10385 w
->phys_cursor
.vpos
= vpos
;
10386 w
->phys_cursor_type
= new_cursor_type
;
10387 w
->phys_cursor_on_p
= 1;
10389 switch (new_cursor_type
)
10391 case HOLLOW_BOX_CURSOR
:
10392 x_draw_hollow_cursor (w
, glyph_row
);
10395 case FILLED_BOX_CURSOR
:
10396 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
10400 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
);
10411 if (w
== XWINDOW (f
->selected_window
))
10412 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
10413 xic_set_preeditarea (w
, x
, y
);
10418 if (updating_frame
!= f
)
10419 XFlush (FRAME_X_DISPLAY (f
));
10424 /* Display the cursor on window W, or clear it. X and Y are window
10425 relative pixel coordinates. HPOS and VPOS are glyph matrix
10426 positions. If W is not the selected window, display a hollow
10427 cursor. ON non-zero means display the cursor at X, Y which
10428 correspond to HPOS, VPOS, otherwise it is cleared. */
10431 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
10433 int on
, hpos
, vpos
, x
, y
;
10436 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
10441 /* Display the cursor on window W, or clear it, according to ON_P.
10442 Don't change the cursor's position. */
10445 x_update_cursor (f
, on_p
)
10448 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
10452 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
10453 in the window tree rooted at W. */
10456 x_update_cursor_in_window_tree (w
, on_p
)
10462 if (!NILP (w
->hchild
))
10463 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
10464 else if (!NILP (w
->vchild
))
10465 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
10467 x_update_window_cursor (w
, on_p
);
10469 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
10474 /* Switch the display of W's cursor on or off, according to the value
10478 x_update_window_cursor (w
, on
)
10482 /* Don't update cursor in windows whose frame is in the process
10483 of being deleted. */
10484 if (w
->current_matrix
)
10487 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
10488 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
10498 /* Refresh bitmap kitchen sink icon for frame F
10499 when we get an expose event for it. */
10505 /* Normally, the window manager handles this function. */
10508 /* Make the x-window of frame F use the gnu icon bitmap. */
10511 x_bitmap_icon (f
, file
)
10517 if (FRAME_X_WINDOW (f
) == 0)
10520 /* Free up our existing icon bitmap if any. */
10521 if (f
->output_data
.x
->icon_bitmap
> 0)
10522 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
10523 f
->output_data
.x
->icon_bitmap
= 0;
10525 if (STRINGP (file
))
10526 bitmap_id
= x_create_bitmap_from_file (f
, file
);
10529 /* Create the GNU bitmap if necessary. */
10530 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
10531 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
10532 = x_create_bitmap_from_data (f
, gnu_bits
,
10533 gnu_width
, gnu_height
);
10535 /* The first time we create the GNU bitmap,
10536 this increments the ref-count one extra time.
10537 As a result, the GNU bitmap is never freed.
10538 That way, we don't have to worry about allocating it again. */
10539 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
10541 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
10544 x_wm_set_icon_pixmap (f
, bitmap_id
);
10545 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
10551 /* Make the x-window of frame F use a rectangle with text.
10552 Use ICON_NAME as the text. */
10555 x_text_icon (f
, icon_name
)
10559 if (FRAME_X_WINDOW (f
) == 0)
10564 XTextProperty text
;
10565 text
.value
= (unsigned char *) icon_name
;
10566 text
.encoding
= XA_STRING
;
10568 text
.nitems
= strlen (icon_name
);
10569 #ifdef USE_X_TOOLKIT
10570 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
10572 #else /* not USE_X_TOOLKIT */
10573 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
10574 #endif /* not USE_X_TOOLKIT */
10576 #else /* not HAVE_X11R4 */
10577 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
10578 #endif /* not HAVE_X11R4 */
10580 if (f
->output_data
.x
->icon_bitmap
> 0)
10581 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
10582 f
->output_data
.x
->icon_bitmap
= 0;
10583 x_wm_set_icon_pixmap (f
, 0);
10588 #define X_ERROR_MESSAGE_SIZE 200
10590 /* If non-nil, this should be a string.
10591 It means catch X errors and store the error message in this string. */
10593 static Lisp_Object x_error_message_string
;
10595 /* An X error handler which stores the error message in
10596 x_error_message_string. This is called from x_error_handler if
10597 x_catch_errors is in effect. */
10600 x_error_catcher (display
, error
)
10602 XErrorEvent
*error
;
10604 XGetErrorText (display
, error
->error_code
,
10605 XSTRING (x_error_message_string
)->data
,
10606 X_ERROR_MESSAGE_SIZE
);
10609 /* Begin trapping X errors for display DPY. Actually we trap X errors
10610 for all displays, but DPY should be the display you are actually
10613 After calling this function, X protocol errors no longer cause
10614 Emacs to exit; instead, they are recorded in the string
10615 stored in x_error_message_string.
10617 Calling x_check_errors signals an Emacs error if an X error has
10618 occurred since the last call to x_catch_errors or x_check_errors.
10620 Calling x_uncatch_errors resumes the normal error handling. */
10622 void x_check_errors ();
10623 static Lisp_Object
x_catch_errors_unwind ();
10626 x_catch_errors (dpy
)
10629 int count
= specpdl_ptr
- specpdl
;
10631 /* Make sure any errors from previous requests have been dealt with. */
10632 XSync (dpy
, False
);
10634 record_unwind_protect (x_catch_errors_unwind
, x_error_message_string
);
10636 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
10637 XSTRING (x_error_message_string
)->data
[0] = 0;
10642 /* Unbind the binding that we made to check for X errors. */
10645 x_catch_errors_unwind (old_val
)
10646 Lisp_Object old_val
;
10648 x_error_message_string
= old_val
;
10652 /* If any X protocol errors have arrived since the last call to
10653 x_catch_errors or x_check_errors, signal an Emacs error using
10654 sprintf (a buffer, FORMAT, the x error message text) as the text. */
10657 x_check_errors (dpy
, format
)
10661 /* Make sure to catch any errors incurred so far. */
10662 XSync (dpy
, False
);
10664 if (XSTRING (x_error_message_string
)->data
[0])
10665 error (format
, XSTRING (x_error_message_string
)->data
);
10668 /* Nonzero if we had any X protocol errors
10669 since we did x_catch_errors on DPY. */
10672 x_had_errors_p (dpy
)
10675 /* Make sure to catch any errors incurred so far. */
10676 XSync (dpy
, False
);
10678 return XSTRING (x_error_message_string
)->data
[0] != 0;
10681 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
10684 x_clear_errors (dpy
)
10687 XSTRING (x_error_message_string
)->data
[0] = 0;
10690 /* Stop catching X protocol errors and let them make Emacs die.
10691 DPY should be the display that was passed to x_catch_errors.
10692 COUNT should be the value that was returned by
10693 the corresponding call to x_catch_errors. */
10696 x_uncatch_errors (dpy
, count
)
10700 unbind_to (count
, Qnil
);
10704 static unsigned int x_wire_count
;
10707 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
10712 /* Handle SIGPIPE, which can happen when the connection to a server
10713 simply goes away. SIGPIPE is handled by x_connection_signal.
10714 Don't need to do anything, because the write which caused the
10715 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
10716 which will do the appropriate cleanup for us. */
10719 x_connection_signal (signalnum
) /* If we don't have an argument, */
10720 int signalnum
; /* some compilers complain in signal calls. */
10723 /* USG systems forget handlers when they are used;
10724 must reestablish each time */
10725 signal (signalnum
, x_connection_signal
);
10729 /* Handling X errors. */
10731 /* Handle the loss of connection to display DISPLAY. */
10734 x_connection_closed (display
, error_message
)
10736 char *error_message
;
10738 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
10739 Lisp_Object frame
, tail
;
10741 /* Indicate that this display is dead. */
10743 #if 0 /* Closing the display caused a bus error on OpenWindows. */
10744 #ifdef USE_X_TOOLKIT
10745 XtCloseDisplay (display
);
10749 dpyinfo
->display
= 0;
10751 /* First delete frames whose mini-buffers are on frames
10752 that are on the dead display. */
10753 FOR_EACH_FRAME (tail
, frame
)
10755 Lisp_Object minibuf_frame
;
10757 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
10758 if (FRAME_X_P (XFRAME (frame
))
10759 && FRAME_X_P (XFRAME (minibuf_frame
))
10760 && ! EQ (frame
, minibuf_frame
)
10761 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
10762 Fdelete_frame (frame
, Qt
);
10765 /* Now delete all remaining frames on the dead display.
10766 We are now sure none of these is used as the mini-buffer
10767 for another frame that we need to delete. */
10768 FOR_EACH_FRAME (tail
, frame
)
10769 if (FRAME_X_P (XFRAME (frame
))
10770 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
10772 /* Set this to t so that Fdelete_frame won't get confused
10773 trying to find a replacement. */
10774 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
10775 Fdelete_frame (frame
, Qt
);
10779 x_delete_display (dpyinfo
);
10781 if (x_display_list
== 0)
10783 fprintf (stderr
, "%s\n", error_message
);
10784 shut_down_emacs (0, 0, Qnil
);
10788 /* Ordinary stack unwind doesn't deal with these. */
10790 sigunblock (sigmask (SIGIO
));
10792 sigunblock (sigmask (SIGALRM
));
10793 TOTALLY_UNBLOCK_INPUT
;
10795 clear_waiting_for_input ();
10796 error ("%s", error_message
);
10799 /* This is the usual handler for X protocol errors.
10800 It kills all frames on the display that we got the error for.
10801 If that was the only one, it prints an error message and kills Emacs. */
10804 x_error_quitter (display
, error
)
10806 XErrorEvent
*error
;
10808 char buf
[256], buf1
[356];
10810 /* Note that there is no real way portable across R3/R4 to get the
10811 original error handler. */
10813 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
10814 sprintf (buf1
, "X protocol error: %s on protocol request %d",
10815 buf
, error
->request_code
);
10816 x_connection_closed (display
, buf1
);
10819 /* This is the first-level handler for X protocol errors.
10820 It calls x_error_quitter or x_error_catcher. */
10823 x_error_handler (display
, error
)
10825 XErrorEvent
*error
;
10827 if (! NILP (x_error_message_string
))
10828 x_error_catcher (display
, error
);
10830 x_error_quitter (display
, error
);
10834 /* This is the handler for X IO errors, always.
10835 It kills all frames on the display that we lost touch with.
10836 If that was the only one, it prints an error message and kills Emacs. */
10839 x_io_error_quitter (display
)
10844 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
10845 x_connection_closed (display
, buf
);
10849 /* Changing the font of the frame. */
10851 /* Give frame F the font named FONTNAME as its default font, and
10852 return the full name of that font. FONTNAME may be a wildcard
10853 pattern; in that case, we choose some font that fits the pattern.
10854 The return value shows which font we chose. */
10857 x_new_font (f
, fontname
)
10859 register char *fontname
;
10861 struct font_info
*fontp
10862 = FS_LOAD_FONT (f
, 0, fontname
, -1);
10867 f
->output_data
.x
->font
= (XFontStruct
*) (fontp
->font
);
10868 f
->output_data
.x
->baseline_offset
= fontp
->baseline_offset
;
10869 f
->output_data
.x
->fontset
= -1;
10871 /* Compute the scroll bar width in character columns. */
10872 if (f
->scroll_bar_pixel_width
> 0)
10874 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
10875 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
10879 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
10880 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
10883 /* Now make the frame display the given font. */
10884 if (FRAME_X_WINDOW (f
) != 0)
10886 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
10887 f
->output_data
.x
->font
->fid
);
10888 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
10889 f
->output_data
.x
->font
->fid
);
10890 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
10891 f
->output_data
.x
->font
->fid
);
10893 frame_update_line_height (f
);
10894 x_set_window_size (f
, 0, f
->width
, f
->height
);
10897 /* If we are setting a new frame's font for the first time,
10898 there are no faces yet, so this font's height is the line height. */
10899 f
->output_data
.x
->line_height
= FONT_HEIGHT (f
->output_data
.x
->font
);
10901 return build_string (fontp
->full_name
);
10904 /* Give frame F the fontset named FONTSETNAME as its default font, and
10905 return the full name of that fontset. FONTSETNAME may be a wildcard
10906 pattern; in that case, we choose some fontset that fits the pattern.
10907 The return value shows which fontset we chose. */
10910 x_new_fontset (f
, fontsetname
)
10914 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
10915 Lisp_Object result
;
10921 if (f
->output_data
.x
->fontset
== fontset
)
10922 /* This fontset is already set in frame F. There's nothing more
10924 return fontset_name (fontset
);
10926 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
10928 if (!STRINGP (result
))
10929 /* Can't load ASCII font. */
10932 /* Since x_new_font doesn't update any fontset information, do it now. */
10933 f
->output_data
.x
->fontset
= fontset
;
10937 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
10938 xic_set_xfontset (f
, XSTRING (fontset_ascii (fontset
))->data
);
10941 return build_string (fontsetname
);
10945 /***********************************************************************
10947 ***********************************************************************/
10953 /* XIM destroy callback function, which is called whenever the
10954 connection to input method XIM dies. CLIENT_DATA contains a
10955 pointer to the x_display_info structure corresponding to XIM. */
10958 xim_destroy_callback (xim
, client_data
, call_data
)
10960 XPointer client_data
;
10961 XPointer call_data
;
10963 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
10964 Lisp_Object frame
, tail
;
10968 /* No need to call XDestroyIC.. */
10969 FOR_EACH_FRAME (tail
, frame
)
10971 struct frame
*f
= XFRAME (frame
);
10972 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
10974 FRAME_XIC (f
) = NULL
;
10975 if (FRAME_XIC_FONTSET (f
))
10977 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
10978 FRAME_XIC_FONTSET (f
) = NULL
;
10983 /* No need to call XCloseIM. */
10984 dpyinfo
->xim
= NULL
;
10985 XFree (dpyinfo
->xim_styles
);
10989 #endif /* HAVE_X11R6 */
10991 /* Open the connection to the XIM server on display DPYINFO.
10992 RESOURCE_NAME is the resource name Emacs uses. */
10995 xim_open_dpy (dpyinfo
, resource_name
)
10996 struct x_display_info
*dpyinfo
;
10997 char *resource_name
;
11001 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
, EMACS_CLASS
);
11002 dpyinfo
->xim
= xim
;
11007 XIMCallback destroy
;
11010 /* Get supported styles and XIM values. */
11011 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
11014 destroy
.callback
= xim_destroy_callback
;
11015 destroy
.client_data
= (XPointer
)dpyinfo
;
11016 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
11022 #ifdef HAVE_X11R6_XIM
11026 struct x_display_info
*dpyinfo
;
11027 char *resource_name
;
11030 /* XIM instantiate callback function, which is called whenever an XIM
11031 server is available. DISPLAY is teh display of the XIM.
11032 CLIENT_DATA contains a pointer to an xim_inst_t structure created
11033 when the callback was registered. */
11036 xim_instantiate_callback (display
, client_data
, call_data
)
11038 XPointer client_data
;
11039 XPointer call_data
;
11041 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
11042 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
11044 /* We don't support multiple XIM connections. */
11048 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
11050 /* Create XIC for the existing frames on the same display, as long
11051 as they have no XIC. */
11052 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
11054 Lisp_Object tail
, frame
;
11057 FOR_EACH_FRAME (tail
, frame
)
11059 struct frame
*f
= XFRAME (frame
);
11061 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
11062 if (FRAME_XIC (f
) == NULL
)
11064 create_frame_xic (f
);
11065 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
11066 xic_set_statusarea (f
);
11067 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
11069 struct window
*w
= XWINDOW (f
->selected_window
);
11070 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
11079 #endif /* HAVE_X11R6_XIM */
11082 /* Open a connection to the XIM server on display DPYINFO.
11083 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
11084 connection only at the first time. On X11R6, open the connection
11085 in the XIM instantiate callback function. */
11088 xim_initialize (dpyinfo
, resource_name
)
11089 struct x_display_info
*dpyinfo
;
11090 char *resource_name
;
11092 #ifdef HAVE_X11R6_XIM
11093 struct xim_inst_t
*xim_inst
;
11096 dpyinfo
->xim
= NULL
;
11097 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
11098 xim_inst
->dpyinfo
= dpyinfo
;
11099 len
= strlen (resource_name
);
11100 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
11101 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
11102 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
11103 resource_name
, EMACS_CLASS
,
11104 xim_instantiate_callback
,
11105 (XPointer
)xim_inst
);
11106 #else /* not HAVE_X11R6_XIM */
11107 dpyinfo
->xim
= NULL
;
11108 xim_open_dpy (dpyinfo
, resource_name
);
11109 #endif /* not HAVE_X11R6_XIM */
11113 /* Close the connection to the XIM server on display DPYINFO. */
11116 xim_close_dpy (dpyinfo
)
11117 struct x_display_info
*dpyinfo
;
11119 #ifdef HAVE_X11R6_XIM
11120 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
11122 xim_instantiate_callback
, NULL
);
11123 #endif /* not HAVE_X11R6_XIM */
11124 XCloseIM (dpyinfo
->xim
);
11125 dpyinfo
->xim
= NULL
;
11126 XFree (dpyinfo
->xim_styles
);
11129 #endif /* not HAVE_X11R6_XIM */
11133 /* Calculate the absolute position in frame F
11134 from its current recorded position values and gravity. */
11137 x_calc_absolute_position (f
)
11141 int win_x
= 0, win_y
= 0;
11142 int flags
= f
->output_data
.x
->size_hint_flags
;
11145 /* We have nothing to do if the current position
11146 is already for the top-left corner. */
11147 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
11150 #ifdef USE_X_TOOLKIT
11151 this_window
= XtWindow (f
->output_data
.x
->widget
);
11153 this_window
= FRAME_X_WINDOW (f
);
11156 /* Find the position of the outside upper-left corner of
11157 the inner window, with respect to the outer window.
11158 But do this only if we will need the results. */
11159 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
11164 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
11167 x_clear_errors (FRAME_X_DISPLAY (f
));
11168 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
11170 /* From-window, to-window. */
11172 f
->output_data
.x
->parent_desc
,
11174 /* From-position, to-position. */
11175 0, 0, &win_x
, &win_y
,
11177 /* Child of win. */
11179 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
11181 Window newroot
, newparent
= 0xdeadbeef;
11182 Window
*newchildren
;
11185 if (! XQueryTree (FRAME_X_DISPLAY (f
), this_window
, &newroot
,
11186 &newparent
, &newchildren
, &nchildren
))
11189 XFree ((char *) newchildren
);
11191 f
->output_data
.x
->parent_desc
= newparent
;
11197 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
11201 /* Treat negative positions as relative to the leftmost bottommost
11202 position that fits on the screen. */
11203 if (flags
& XNegative
)
11204 f
->output_data
.x
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
11205 - 2 * f
->output_data
.x
->border_width
- win_x
11207 + f
->output_data
.x
->left_pos
);
11209 if (flags
& YNegative
)
11211 int menubar_height
= 0;
11213 #ifdef USE_X_TOOLKIT
11214 if (f
->output_data
.x
->menubar_widget
)
11216 = (f
->output_data
.x
->menubar_widget
->core
.height
11217 + f
->output_data
.x
->menubar_widget
->core
.border_width
);
11220 f
->output_data
.x
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
11221 - 2 * f
->output_data
.x
->border_width
11225 + f
->output_data
.x
->top_pos
);
11228 /* The left_pos and top_pos
11229 are now relative to the top and left screen edges,
11230 so the flags should correspond. */
11231 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
11234 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
11235 to really change the position, and 0 when calling from
11236 x_make_frame_visible (in that case, XOFF and YOFF are the current
11237 position values). It is -1 when calling from x_set_frame_parameters,
11238 which means, do adjust for borders but don't change the gravity. */
11241 x_set_offset (f
, xoff
, yoff
, change_gravity
)
11243 register int xoff
, yoff
;
11244 int change_gravity
;
11246 int modified_top
, modified_left
;
11248 if (change_gravity
> 0)
11250 f
->output_data
.x
->top_pos
= yoff
;
11251 f
->output_data
.x
->left_pos
= xoff
;
11252 f
->output_data
.x
->size_hint_flags
&= ~ (XNegative
| YNegative
);
11254 f
->output_data
.x
->size_hint_flags
|= XNegative
;
11256 f
->output_data
.x
->size_hint_flags
|= YNegative
;
11257 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11259 x_calc_absolute_position (f
);
11262 x_wm_set_size_hint (f
, (long) 0, 0);
11264 modified_left
= f
->output_data
.x
->left_pos
;
11265 modified_top
= f
->output_data
.x
->top_pos
;
11266 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
11267 this seems to be unnecessary and incorrect. rms, 4/17/97. */
11268 /* It is a mystery why we need to add the border_width here
11269 when the frame is already visible, but experiment says we do. */
11270 if (change_gravity
!= 0)
11272 modified_left
+= f
->output_data
.x
->border_width
;
11273 modified_top
+= f
->output_data
.x
->border_width
;
11277 #ifdef USE_X_TOOLKIT
11278 XMoveWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
11279 modified_left
, modified_top
);
11280 #else /* not USE_X_TOOLKIT */
11281 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11282 modified_left
, modified_top
);
11283 #endif /* not USE_X_TOOLKIT */
11287 /* Call this to change the size of frame F's x-window.
11288 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
11289 for this size change and subsequent size changes.
11290 Otherwise we leave the window gravity unchanged. */
11293 x_set_window_size (f
, change_gravity
, cols
, rows
)
11295 int change_gravity
;
11298 #ifndef USE_X_TOOLKIT
11299 int pixelwidth
, pixelheight
;
11304 #ifdef USE_X_TOOLKIT
11306 /* The x and y position of the widget is clobbered by the
11307 call to XtSetValues within EmacsFrameSetCharSize.
11308 This is a real kludge, but I don't understand Xt so I can't
11309 figure out a correct fix. Can anyone else tell me? -- rms. */
11310 int xpos
= f
->output_data
.x
->widget
->core
.x
;
11311 int ypos
= f
->output_data
.x
->widget
->core
.y
;
11312 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
11313 f
->output_data
.x
->widget
->core
.x
= xpos
;
11314 f
->output_data
.x
->widget
->core
.y
= ypos
;
11317 #else /* not USE_X_TOOLKIT */
11319 check_frame_size (f
, &rows
, &cols
);
11320 f
->output_data
.x
->vertical_scroll_bar_extra
11321 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
11323 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
11324 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
11325 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.x
->font
)));
11326 f
->output_data
.x
->flags_areas_extra
11327 = FRAME_FLAGS_AREA_WIDTH (f
);
11328 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
11329 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
11331 f
->output_data
.x
->win_gravity
= NorthWestGravity
;
11332 x_wm_set_size_hint (f
, (long) 0, 0);
11334 XSync (FRAME_X_DISPLAY (f
), False
);
11335 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11336 pixelwidth
, pixelheight
);
11338 /* Now, strictly speaking, we can't be sure that this is accurate,
11339 but the window manager will get around to dealing with the size
11340 change request eventually, and we'll hear how it went when the
11341 ConfigureNotify event gets here.
11343 We could just not bother storing any of this information here,
11344 and let the ConfigureNotify event set everything up, but that
11345 might be kind of confusing to the Lisp code, since size changes
11346 wouldn't be reported in the frame parameters until some random
11347 point in the future when the ConfigureNotify event arrives.
11349 We pass 1 for DELAY since we can't run Lisp code inside of
11351 change_frame_size (f
, rows
, cols
, 0, 1, 0);
11352 PIXEL_WIDTH (f
) = pixelwidth
;
11353 PIXEL_HEIGHT (f
) = pixelheight
;
11355 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
11356 receive in the ConfigureNotify event; if we get what we asked
11357 for, then the event won't cause the screen to become garbaged, so
11358 we have to make sure to do it here. */
11359 SET_FRAME_GARBAGED (f
);
11361 XFlush (FRAME_X_DISPLAY (f
));
11363 #endif /* not USE_X_TOOLKIT */
11365 /* If cursor was outside the new size, mark it as off. */
11366 mark_window_cursors_off (XWINDOW (f
->root_window
));
11368 /* Clear out any recollection of where the mouse highlighting was,
11369 since it might be in a place that's outside the new frame size.
11370 Actually checking whether it is outside is a pain in the neck,
11371 so don't try--just let the highlighting be done afresh with new size. */
11372 cancel_mouse_face (f
);
11377 /* Mouse warping. */
11380 x_set_mouse_position (f
, x
, y
)
11386 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.x
->font
) / 2;
11387 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.x
->line_height
/ 2;
11389 if (pix_x
< 0) pix_x
= 0;
11390 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
11392 if (pix_y
< 0) pix_y
= 0;
11393 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
11397 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
11398 0, 0, 0, 0, pix_x
, pix_y
);
11402 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
11405 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
11411 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
11412 0, 0, 0, 0, pix_x
, pix_y
);
11416 /* focus shifting, raising and lowering. */
11419 x_focus_on_frame (f
)
11422 #if 0 /* This proves to be unpleasant. */
11426 /* I don't think that the ICCCM allows programs to do things like this
11427 without the interaction of the window manager. Whatever you end up
11428 doing with this code, do it to x_unfocus_frame too. */
11429 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11430 RevertToPointerRoot
, CurrentTime
);
11435 x_unfocus_frame (f
)
11439 /* Look at the remarks in x_focus_on_frame. */
11440 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
11441 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
11442 RevertToPointerRoot
, CurrentTime
);
11446 /* Raise frame F. */
11452 if (f
->async_visible
)
11455 #ifdef USE_X_TOOLKIT
11456 XRaiseWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
11457 #else /* not USE_X_TOOLKIT */
11458 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11459 #endif /* not USE_X_TOOLKIT */
11460 XFlush (FRAME_X_DISPLAY (f
));
11465 /* Lower frame F. */
11471 if (f
->async_visible
)
11474 #ifdef USE_X_TOOLKIT
11475 XLowerWindow (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
));
11476 #else /* not USE_X_TOOLKIT */
11477 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11478 #endif /* not USE_X_TOOLKIT */
11479 XFlush (FRAME_X_DISPLAY (f
));
11485 XTframe_raise_lower (f
, raise_flag
)
11495 /* Change of visibility. */
11497 /* This tries to wait until the frame is really visible.
11498 However, if the window manager asks the user where to position
11499 the frame, this will return before the user finishes doing that.
11500 The frame will not actually be visible at that time,
11501 but it will become visible later when the window manager
11502 finishes with it. */
11505 x_make_frame_visible (f
)
11509 int original_top
, original_left
;
11513 type
= x_icon_type (f
);
11515 x_bitmap_icon (f
, type
);
11517 if (! FRAME_VISIBLE_P (f
))
11519 /* We test FRAME_GARBAGED_P here to make sure we don't
11520 call x_set_offset a second time
11521 if we get to x_make_frame_visible a second time
11522 before the window gets really visible. */
11523 if (! FRAME_ICONIFIED_P (f
)
11524 && ! f
->output_data
.x
->asked_for_visible
)
11525 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
11527 f
->output_data
.x
->asked_for_visible
= 1;
11529 if (! EQ (Vx_no_window_manager
, Qt
))
11530 x_wm_set_window_state (f
, NormalState
);
11531 #ifdef USE_X_TOOLKIT
11532 /* This was XtPopup, but that did nothing for an iconified frame. */
11533 XtMapWidget (f
->output_data
.x
->widget
);
11534 #else /* not USE_X_TOOLKIT */
11535 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11536 #endif /* not USE_X_TOOLKIT */
11537 #if 0 /* This seems to bring back scroll bars in the wrong places
11538 if the window configuration has changed. They seem
11539 to come back ok without this. */
11540 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
11541 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11545 XFlush (FRAME_X_DISPLAY (f
));
11547 /* Synchronize to ensure Emacs knows the frame is visible
11548 before we do anything else. We do this loop with input not blocked
11549 so that incoming events are handled. */
11553 /* This must be before UNBLOCK_INPUT
11554 since events that arrive in response to the actions above
11555 will set it when they are handled. */
11556 int previously_visible
= f
->output_data
.x
->has_been_visible
;
11558 original_left
= f
->output_data
.x
->left_pos
;
11559 original_top
= f
->output_data
.x
->top_pos
;
11561 /* This must come after we set COUNT. */
11564 /* We unblock here so that arriving X events are processed. */
11566 /* Now move the window back to where it was "supposed to be".
11567 But don't do it if the gravity is negative.
11568 When the gravity is negative, this uses a position
11569 that is 3 pixels too low. Perhaps that's really the border width.
11571 Don't do this if the window has never been visible before,
11572 because the window manager may choose the position
11573 and we don't want to override it. */
11575 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
11576 && f
->output_data
.x
->win_gravity
== NorthWestGravity
11577 && previously_visible
)
11581 unsigned int width
, height
, border
, depth
;
11585 /* On some window managers (such as FVWM) moving an existing
11586 window, even to the same place, causes the window manager
11587 to introduce an offset. This can cause the window to move
11588 to an unexpected location. Check the geometry (a little
11589 slow here) and then verify that the window is in the right
11590 place. If the window is not in the right place, move it
11591 there, and take the potential window manager hit. */
11592 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
11593 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
11595 if (original_left
!= x
|| original_top
!= y
)
11596 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
11597 original_left
, original_top
);
11602 XSETFRAME (frame
, f
);
11604 /* Wait until the frame is visible. Process X events until a
11605 MapNotify event has been seen, or until we think we won't get a
11606 MapNotify at all.. */
11607 for (count
= input_signal_count
+ 10;
11608 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
11610 /* Force processing of queued events. */
11613 /* Machines that do polling rather than SIGIO have been
11614 observed to go into a busy-wait here. So we'll fake an
11615 alarm signal to let the handler know that there's something
11616 to be read. We used to raise a real alarm, but it seems
11617 that the handler isn't always enabled here. This is
11619 if (input_polling_used ())
11621 /* It could be confusing if a real alarm arrives while
11622 processing the fake one. Turn it off and let the
11623 handler reset it. */
11624 int old_poll_suppress_count
= poll_suppress_count
;
11625 poll_suppress_count
= 1;
11626 poll_for_input_1 ();
11627 poll_suppress_count
= old_poll_suppress_count
;
11630 /* See if a MapNotify event has been processed. */
11631 FRAME_SAMPLE_VISIBILITY (f
);
11636 /* Change from mapped state to withdrawn state. */
11638 /* Make the frame visible (mapped and not iconified). */
11641 x_make_frame_invisible (f
)
11646 #ifdef USE_X_TOOLKIT
11647 /* Use the frame's outermost window, not the one we normally draw on. */
11648 window
= XtWindow (f
->output_data
.x
->widget
);
11649 #else /* not USE_X_TOOLKIT */
11650 window
= FRAME_X_WINDOW (f
);
11651 #endif /* not USE_X_TOOLKIT */
11653 /* Don't keep the highlight on an invisible frame. */
11654 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
11655 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
11657 #if 0/* This might add unreliability; I don't trust it -- rms. */
11658 if (! f
->async_visible
&& ! f
->async_iconified
)
11664 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
11665 that the current position of the window is user-specified, rather than
11666 program-specified, so that when the window is mapped again, it will be
11667 placed at the same location, without forcing the user to position it
11668 by hand again (they have already done that once for this window.) */
11669 x_wm_set_size_hint (f
, (long) 0, 1);
11673 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
11674 DefaultScreen (FRAME_X_DISPLAY (f
))))
11676 UNBLOCK_INPUT_RESIGNAL
;
11677 error ("Can't notify window manager of window withdrawal");
11679 #else /* ! defined (HAVE_X11R4) */
11681 /* Tell the window manager what we're going to do. */
11682 if (! EQ (Vx_no_window_manager
, Qt
))
11686 unmap
.xunmap
.type
= UnmapNotify
;
11687 unmap
.xunmap
.window
= window
;
11688 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
11689 unmap
.xunmap
.from_configure
= False
;
11690 if (! XSendEvent (FRAME_X_DISPLAY (f
),
11691 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
11693 SubstructureRedirectMaskSubstructureNotifyMask
,
11696 UNBLOCK_INPUT_RESIGNAL
;
11697 error ("Can't notify window manager of withdrawal");
11701 /* Unmap the window ourselves. Cheeky! */
11702 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
11703 #endif /* ! defined (HAVE_X11R4) */
11705 /* We can't distinguish this from iconification
11706 just by the event that we get from the server.
11707 So we can't win using the usual strategy of letting
11708 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
11709 and synchronize with the server to make sure we agree. */
11711 FRAME_ICONIFIED_P (f
) = 0;
11712 f
->async_visible
= 0;
11713 f
->async_iconified
= 0;
11720 /* Change window state from mapped to iconified. */
11723 x_iconify_frame (f
)
11729 /* Don't keep the highlight on an invisible frame. */
11730 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
11731 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
11733 if (f
->async_iconified
)
11738 FRAME_SAMPLE_VISIBILITY (f
);
11740 type
= x_icon_type (f
);
11742 x_bitmap_icon (f
, type
);
11744 #ifdef USE_X_TOOLKIT
11746 if (! FRAME_VISIBLE_P (f
))
11748 if (! EQ (Vx_no_window_manager
, Qt
))
11749 x_wm_set_window_state (f
, IconicState
);
11750 /* This was XtPopup, but that did nothing for an iconified frame. */
11751 XtMapWidget (f
->output_data
.x
->widget
);
11752 /* The server won't give us any event to indicate
11753 that an invisible frame was changed to an icon,
11754 so we have to record it here. */
11757 f
->async_iconified
= 1;
11758 f
->async_visible
= 0;
11763 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
11764 XtWindow (f
->output_data
.x
->widget
),
11765 DefaultScreen (FRAME_X_DISPLAY (f
)));
11769 error ("Can't notify window manager of iconification");
11771 f
->async_iconified
= 1;
11772 f
->async_visible
= 0;
11776 XFlush (FRAME_X_DISPLAY (f
));
11778 #else /* not USE_X_TOOLKIT */
11780 /* Make sure the X server knows where the window should be positioned,
11781 in case the user deiconifies with the window manager. */
11782 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
11783 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
11785 /* Since we don't know which revision of X we're running, we'll use both
11786 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
11788 /* X11R4: send a ClientMessage to the window manager using the
11789 WM_CHANGE_STATE type. */
11793 message
.xclient
.window
= FRAME_X_WINDOW (f
);
11794 message
.xclient
.type
= ClientMessage
;
11795 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
11796 message
.xclient
.format
= 32;
11797 message
.xclient
.data
.l
[0] = IconicState
;
11799 if (! XSendEvent (FRAME_X_DISPLAY (f
),
11800 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
11802 SubstructureRedirectMask
| SubstructureNotifyMask
,
11805 UNBLOCK_INPUT_RESIGNAL
;
11806 error ("Can't notify window manager of iconification");
11810 /* X11R3: set the initial_state field of the window manager hints to
11812 x_wm_set_window_state (f
, IconicState
);
11814 if (!FRAME_VISIBLE_P (f
))
11816 /* If the frame was withdrawn, before, we must map it. */
11817 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11820 f
->async_iconified
= 1;
11821 f
->async_visible
= 0;
11823 XFlush (FRAME_X_DISPLAY (f
));
11825 #endif /* not USE_X_TOOLKIT */
11828 /* Destroy the X window of frame F. */
11831 x_destroy_window (f
)
11834 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11838 /* If a display connection is dead, don't try sending more
11839 commands to the X server. */
11840 if (dpyinfo
->display
!= 0)
11842 if (f
->output_data
.x
->icon_desc
!= 0)
11843 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
11846 free_frame_xic (f
);
11848 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->window_desc
);
11849 #ifdef USE_X_TOOLKIT
11850 if (f
->output_data
.x
->widget
)
11851 XtDestroyWidget (f
->output_data
.x
->widget
);
11852 free_frame_menubar (f
);
11853 #endif /* USE_X_TOOLKIT */
11855 free_frame_faces (f
);
11856 XFlush (FRAME_X_DISPLAY (f
));
11859 if (f
->output_data
.x
->saved_menu_event
)
11860 xfree (f
->output_data
.x
->saved_menu_event
);
11862 xfree (f
->output_data
.x
);
11863 f
->output_data
.x
= 0;
11864 if (f
== dpyinfo
->x_focus_frame
)
11865 dpyinfo
->x_focus_frame
= 0;
11866 if (f
== dpyinfo
->x_focus_event_frame
)
11867 dpyinfo
->x_focus_event_frame
= 0;
11868 if (f
== dpyinfo
->x_highlight_frame
)
11869 dpyinfo
->x_highlight_frame
= 0;
11871 dpyinfo
->reference_count
--;
11873 if (f
== dpyinfo
->mouse_face_mouse_frame
)
11875 dpyinfo
->mouse_face_beg_row
11876 = dpyinfo
->mouse_face_beg_col
= -1;
11877 dpyinfo
->mouse_face_end_row
11878 = dpyinfo
->mouse_face_end_col
= -1;
11879 dpyinfo
->mouse_face_window
= Qnil
;
11880 dpyinfo
->mouse_face_deferred_gc
= 0;
11881 dpyinfo
->mouse_face_mouse_frame
= 0;
11887 /* Setting window manager hints. */
11889 /* Set the normal size hints for the window manager, for frame F.
11890 FLAGS is the flags word to use--or 0 meaning preserve the flags
11891 that the window now has.
11892 If USER_POSITION is nonzero, we set the USPosition
11893 flag (this is useful when FLAGS is 0). */
11896 x_wm_set_size_hint (f
, flags
, user_position
)
11901 XSizeHints size_hints
;
11903 #ifdef USE_X_TOOLKIT
11906 Dimension widget_width
, widget_height
;
11907 Window window
= XtWindow (f
->output_data
.x
->widget
);
11908 #else /* not USE_X_TOOLKIT */
11909 Window window
= FRAME_X_WINDOW (f
);
11910 #endif /* not USE_X_TOOLKIT */
11912 /* Setting PMaxSize caused various problems. */
11913 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
11915 size_hints
.x
= f
->output_data
.x
->left_pos
;
11916 size_hints
.y
= f
->output_data
.x
->top_pos
;
11918 #ifdef USE_X_TOOLKIT
11919 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
11920 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
11921 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
11922 size_hints
.height
= widget_height
;
11923 size_hints
.width
= widget_width
;
11924 #else /* not USE_X_TOOLKIT */
11925 size_hints
.height
= PIXEL_HEIGHT (f
);
11926 size_hints
.width
= PIXEL_WIDTH (f
);
11927 #endif /* not USE_X_TOOLKIT */
11929 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
11930 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
11931 size_hints
.max_width
11932 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
11933 size_hints
.max_height
11934 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
11936 /* Calculate the base and minimum sizes.
11938 (When we use the X toolkit, we don't do it here.
11939 Instead we copy the values that the widgets are using, below.) */
11940 #ifndef USE_X_TOOLKIT
11942 int base_width
, base_height
;
11943 int min_rows
= 0, min_cols
= 0;
11945 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
11946 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
11948 check_frame_size (f
, &min_rows
, &min_cols
);
11950 /* The window manager uses the base width hints to calculate the
11951 current number of rows and columns in the frame while
11952 resizing; min_width and min_height aren't useful for this
11953 purpose, since they might not give the dimensions for a
11954 zero-row, zero-column frame.
11956 We use the base_width and base_height members if we have
11957 them; otherwise, we set the min_width and min_height members
11958 to the size for a zero x zero frame. */
11961 size_hints
.flags
|= PBaseSize
;
11962 size_hints
.base_width
= base_width
;
11963 size_hints
.base_height
= base_height
;
11964 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
11965 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
11967 size_hints
.min_width
= base_width
;
11968 size_hints
.min_height
= base_height
;
11972 /* If we don't need the old flags, we don't need the old hint at all. */
11975 size_hints
.flags
|= flags
;
11978 #endif /* not USE_X_TOOLKIT */
11981 XSizeHints hints
; /* Sometimes I hate X Windows... */
11982 long supplied_return
;
11986 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
11989 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
11992 #ifdef USE_X_TOOLKIT
11993 size_hints
.base_height
= hints
.base_height
;
11994 size_hints
.base_width
= hints
.base_width
;
11995 size_hints
.min_height
= hints
.min_height
;
11996 size_hints
.min_width
= hints
.min_width
;
12000 size_hints
.flags
|= flags
;
12005 if (hints
.flags
& PSize
)
12006 size_hints
.flags
|= PSize
;
12007 if (hints
.flags
& PPosition
)
12008 size_hints
.flags
|= PPosition
;
12009 if (hints
.flags
& USPosition
)
12010 size_hints
.flags
|= USPosition
;
12011 if (hints
.flags
& USSize
)
12012 size_hints
.flags
|= USSize
;
12016 #ifndef USE_X_TOOLKIT
12021 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
12022 size_hints
.flags
|= PWinGravity
;
12026 size_hints
.flags
&= ~ PPosition
;
12027 size_hints
.flags
|= USPosition
;
12029 #endif /* PWinGravity */
12032 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
12034 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
12038 /* Used for IconicState or NormalState */
12041 x_wm_set_window_state (f
, state
)
12045 #ifdef USE_X_TOOLKIT
12048 XtSetArg (al
[0], XtNinitialState
, state
);
12049 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
12050 #else /* not USE_X_TOOLKIT */
12051 Window window
= FRAME_X_WINDOW (f
);
12053 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
12054 f
->output_data
.x
->wm_hints
.initial_state
= state
;
12056 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12057 #endif /* not USE_X_TOOLKIT */
12061 x_wm_set_icon_pixmap (f
, pixmap_id
)
12065 Pixmap icon_pixmap
;
12067 #ifndef USE_X_TOOLKIT
12068 Window window
= FRAME_X_WINDOW (f
);
12073 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
12074 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
12078 /* It seems there is no way to turn off use of an icon pixmap.
12079 The following line does it, only if no icon has yet been created,
12080 for some window managers. But with mwm it crashes.
12081 Some people say it should clear the IconPixmapHint bit in this case,
12082 but that doesn't work, and the X consortium said it isn't the
12083 right thing at all. Since there is no way to win,
12084 best to explicitly give up. */
12086 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
12092 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
12096 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
12097 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
12100 #else /* not USE_X_TOOLKIT */
12102 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
12103 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12105 #endif /* not USE_X_TOOLKIT */
12109 x_wm_set_icon_position (f
, icon_x
, icon_y
)
12111 int icon_x
, icon_y
;
12113 #ifdef USE_X_TOOLKIT
12114 Window window
= XtWindow (f
->output_data
.x
->widget
);
12116 Window window
= FRAME_X_WINDOW (f
);
12119 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
12120 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
12121 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
12123 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
12127 /***********************************************************************
12129 ***********************************************************************/
12131 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
12134 x_get_font_info (f
, font_idx
)
12138 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
12142 /* Return a list of names of available fonts matching PATTERN on frame
12143 F. If SIZE is not 0, it is the size (maximum bound width) of fonts
12144 to be listed. Frame F NULL means we have not yet created any
12145 frame on X, and consult the first display in x_display_list.
12146 MAXNAMES sets a limit on how many fonts to match. */
12149 x_list_fonts (f
, pattern
, size
, maxnames
)
12151 Lisp_Object pattern
;
12155 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
12156 Lisp_Object tem
, second_best
;
12157 Display
*dpy
= f
!= NULL
? FRAME_X_DISPLAY (f
) : x_display_list
->display
;
12158 int try_XLoadQueryFont
= 0;
12161 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
12162 if (NILP (patterns
))
12163 patterns
= Fcons (pattern
, Qnil
);
12165 if (maxnames
== 1 && !size
)
12166 /* We can return any single font matching PATTERN. */
12167 try_XLoadQueryFont
= 1;
12169 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
12174 pattern
= XCAR (patterns
);
12175 /* See if we cached the result for this particular query.
12176 The cache is an alist of the form:
12177 (((PATTERN . MAXNAMES) (FONTNAME . WIDTH) ...) ...)
12179 if (f
&& (tem
= XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
),
12180 key
= Fcons (pattern
, make_number (maxnames
)),
12181 !NILP (list
= Fassoc (key
, tem
))))
12183 list
= Fcdr_safe (list
);
12184 /* We have a cashed list. Don't have to get the list again. */
12188 /* At first, put PATTERN in the cache. */
12191 count
= x_catch_errors (dpy
);
12193 if (try_XLoadQueryFont
)
12196 unsigned long value
;
12198 font
= XLoadQueryFont (dpy
, XSTRING (pattern
)->data
);
12199 if (x_had_errors_p (dpy
))
12201 /* This error is perhaps due to insufficient memory on X
12202 server. Let's just ignore it. */
12204 x_clear_errors (dpy
);
12208 && XGetFontProperty (font
, XA_FONT
, &value
))
12210 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
12211 int len
= strlen (name
);
12214 /* If DXPC (a Differential X Protocol Compressor)
12215 Ver.3.7 is running, XGetAtomName will return null
12216 string. We must avoid such a name. */
12218 try_XLoadQueryFont
= 0;
12222 names
= (char **) alloca (sizeof (char *));
12223 /* Some systems only allow alloca assigned to a
12225 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
12226 bcopy (name
, names
[0], len
+ 1);
12231 try_XLoadQueryFont
= 0;
12234 XFreeFont (dpy
, font
);
12237 if (!try_XLoadQueryFont
)
12239 /* We try at least 10 fonts because XListFonts will return
12240 auto-scaled fonts at the head. */
12241 names
= XListFonts (dpy
, XSTRING (pattern
)->data
, max (maxnames
, 10),
12243 if (x_had_errors_p (dpy
))
12245 /* This error is perhaps due to insufficient memory on X
12246 server. Let's just ignore it. */
12248 x_clear_errors (dpy
);
12252 x_uncatch_errors (dpy
, count
);
12259 /* Make a list of all the fonts we got back.
12260 Store that in the font cache for the display. */
12261 for (i
= 0; i
< num_fonts
; i
++)
12264 char *p
= names
[i
];
12265 int average_width
= -1, dashes
= 0;
12267 /* Count the number of dashes in NAMES[I]. If there are
12268 14 dashes, and the field value following 12th dash
12269 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
12270 is usually too ugly to be used for editing. Let's
12276 if (dashes
== 7) /* PIXEL_SIZE field */
12278 else if (dashes
== 12) /* AVERAGE_WIDTH field */
12279 average_width
= atoi (p
);
12281 if (dashes
< 14 || average_width
!= 0)
12283 tem
= build_string (names
[i
]);
12284 if (NILP (Fassoc (tem
, list
)))
12286 if (STRINGP (Vx_pixel_size_width_font_regexp
)
12287 && ((fast_c_string_match_ignore_case
12288 (Vx_pixel_size_width_font_regexp
, names
[i
]))
12290 /* We can set the value of PIXEL_SIZE to the
12291 width of this font. */
12292 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
12294 /* For the moment, width is not known. */
12295 list
= Fcons (Fcons (tem
, Qnil
), list
);
12299 if (!try_XLoadQueryFont
)
12300 XFreeFontNames (names
);
12303 /* Now store the result in the cache. */
12305 XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
)
12306 = Fcons (Fcons (key
, list
),
12307 XCDR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
));
12310 if (NILP (list
)) continue; /* Try the remaining alternatives. */
12312 newlist
= second_best
= Qnil
;
12313 /* Make a list of the fonts that have the right width. */
12314 for (; CONSP (list
); list
= XCDR (list
))
12320 if (!CONSP (tem
) || NILP (XCAR (tem
)))
12324 newlist
= Fcons (XCAR (tem
), newlist
);
12328 if (!INTEGERP (XCDR (tem
)))
12330 /* Since we have not yet known the size of this font, we
12331 must try slow function call XLoadQueryFont. */
12332 XFontStruct
*thisinfo
;
12335 count
= x_catch_errors (dpy
);
12336 thisinfo
= XLoadQueryFont (dpy
,
12337 XSTRING (XCAR (tem
))->data
);
12338 if (x_had_errors_p (dpy
))
12340 /* This error is perhaps due to insufficient memory on X
12341 server. Let's just ignore it. */
12343 x_clear_errors (dpy
);
12345 x_uncatch_errors (dpy
, count
);
12351 = (thisinfo
->min_bounds
.width
== 0
12353 : make_number (thisinfo
->max_bounds
.width
));
12354 XFreeFont (dpy
, thisinfo
);
12357 /* For unknown reason, the previous call of XListFont had
12358 returned a font which can't be opened. Record the size
12359 as 0 not to try to open it again. */
12360 XCDR (tem
) = make_number (0);
12363 found_size
= XINT (XCDR (tem
));
12364 if (found_size
== size
)
12365 newlist
= Fcons (XCAR (tem
), newlist
);
12366 else if (found_size
> 0)
12368 if (NILP (second_best
))
12370 else if (found_size
< size
)
12372 if (XINT (XCDR (second_best
)) > size
12373 || XINT (XCDR (second_best
)) < found_size
)
12378 if (XINT (XCDR (second_best
)) > size
12379 && XINT (XCDR (second_best
)) > found_size
)
12384 if (!NILP (newlist
))
12386 else if (!NILP (second_best
))
12388 newlist
= Fcons (XCAR (second_best
), Qnil
);
12399 /* Check that FONT is valid on frame F. It is if it can be found in F's
12403 x_check_font (f
, font
)
12408 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12410 xassert (font
!= NULL
);
12412 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12413 if (dpyinfo
->font_table
[i
].name
12414 && font
== dpyinfo
->font_table
[i
].font
)
12417 xassert (i
< dpyinfo
->n_fonts
);
12420 #endif /* GLYPH_DEBUG != 0 */
12422 /* Set *W to the minimum width, *H to the minimum font height of FONT.
12423 Note: There are (broken) X fonts out there with invalid XFontStruct
12424 min_bounds contents. For example, handa@etl.go.jp reports that
12425 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
12426 have font->min_bounds.width == 0. */
12429 x_font_min_bounds (font
, w
, h
)
12433 *h
= FONT_HEIGHT (font
);
12434 *w
= font
->min_bounds
.width
;
12436 /* Try to handle the case where FONT->min_bounds has invalid
12437 contents. Since the only font known to have invalid min_bounds
12438 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
12440 *w
= font
->max_bounds
.width
;
12444 /* Compute the smallest character width and smallest font height over
12445 all fonts available on frame F. Set the members smallest_char_width
12446 and smallest_font_height in F's x_display_info structure to
12447 the values computed. Value is non-zero if smallest_font_height or
12448 smallest_char_width become smaller than they were before. */
12451 x_compute_min_glyph_bounds (f
)
12455 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12457 int old_width
= dpyinfo
->smallest_char_width
;
12458 int old_height
= dpyinfo
->smallest_font_height
;
12460 dpyinfo
->smallest_font_height
= 100000;
12461 dpyinfo
->smallest_char_width
= 100000;
12463 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
12464 if (dpyinfo
->font_table
[i
].name
)
12466 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
12469 font
= (XFontStruct
*) fontp
->font
;
12470 xassert (font
!= (XFontStruct
*) ~0);
12471 x_font_min_bounds (font
, &w
, &h
);
12473 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
12474 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
12477 xassert (dpyinfo
->smallest_char_width
> 0
12478 && dpyinfo
->smallest_font_height
> 0);
12480 return (dpyinfo
->n_fonts
== 1
12481 || dpyinfo
->smallest_char_width
< old_width
12482 || dpyinfo
->smallest_font_height
< old_height
);
12486 /* Load font named FONTNAME of the size SIZE for frame F, and return a
12487 pointer to the structure font_info while allocating it dynamically.
12488 If SIZE is 0, load any size of font.
12489 If loading is failed, return NULL. */
12492 x_load_font (f
, fontname
, size
)
12494 register char *fontname
;
12497 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12498 Lisp_Object font_names
;
12501 /* Get a list of all the fonts that match this name. Once we
12502 have a list of matching fonts, we compare them against the fonts
12503 we already have by comparing names. */
12504 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
12506 if (!NILP (font_names
))
12511 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12512 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
12513 if (dpyinfo
->font_table
[i
].name
12514 && (!strcmp (dpyinfo
->font_table
[i
].name
,
12515 XSTRING (XCAR (tail
))->data
)
12516 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
12517 XSTRING (XCAR (tail
))->data
)))
12518 return (dpyinfo
->font_table
+ i
);
12521 /* Load the font and add it to the table. */
12525 struct font_info
*fontp
;
12526 unsigned long value
;
12529 /* If we have found fonts by x_list_font, load one of them. If
12530 not, we still try to load a font by the name given as FONTNAME
12531 because XListFonts (called in x_list_font) of some X server has
12532 a bug of not finding a font even if the font surely exists and
12533 is loadable by XLoadQueryFont. */
12534 if (size
> 0 && !NILP (font_names
))
12535 fontname
= (char *) XSTRING (XCAR (font_names
))->data
;
12538 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
12539 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
12540 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
12542 /* This error is perhaps due to insufficient memory on X
12543 server. Let's just ignore it. */
12545 x_clear_errors (FRAME_X_DISPLAY (f
));
12547 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
12552 /* Find a free slot in the font table. */
12553 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
12554 if (dpyinfo
->font_table
[i
].name
== NULL
)
12557 /* If no free slot found, maybe enlarge the font table. */
12558 if (i
== dpyinfo
->n_fonts
12559 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
12562 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
12563 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
12564 dpyinfo
->font_table
12565 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
12568 fontp
= dpyinfo
->font_table
+ i
;
12569 if (i
== dpyinfo
->n_fonts
)
12570 ++dpyinfo
->n_fonts
;
12572 /* Now fill in the slots of *FONTP. */
12574 fontp
->font
= font
;
12575 fontp
->font_idx
= i
;
12576 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
12577 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
12579 /* Try to get the full name of FONT. Put it in FULL_NAME. */
12581 if (XGetFontProperty (font
, XA_FONT
, &value
))
12583 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
12587 /* Count the number of dashes in the "full name".
12588 If it is too few, this isn't really the font's full name,
12590 In X11R4, the fonts did not come with their canonical names
12601 full_name
= (char *) xmalloc (p
- name
+ 1);
12602 bcopy (name
, full_name
, p
- name
+ 1);
12608 if (full_name
!= 0)
12609 fontp
->full_name
= full_name
;
12611 fontp
->full_name
= fontp
->name
;
12613 fontp
->size
= font
->max_bounds
.width
;
12614 fontp
->height
= FONT_HEIGHT (font
);
12616 /* For some font, ascent and descent in max_bounds field is
12617 larger than the above value. */
12618 int max_height
= font
->max_bounds
.ascent
+ font
->max_bounds
.descent
;
12619 if (max_height
> fontp
->height
)
12620 fontp
->height
= max_height
;
12623 if (NILP (font_names
))
12625 /* We come here because of a bug of XListFonts mentioned at
12626 the head of this block. Let's store this information in
12627 the cache for x_list_fonts. */
12628 Lisp_Object lispy_name
= build_string (fontname
);
12629 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
12631 XCDR (dpyinfo
->name_list_element
)
12632 = Fcons (Fcons (Fcons (lispy_name
, make_number (256)),
12633 Fcons (Fcons (lispy_full_name
,
12634 make_number (fontp
->size
)),
12636 XCDR (dpyinfo
->name_list_element
));
12638 XCDR (dpyinfo
->name_list_element
)
12639 = Fcons (Fcons (Fcons (lispy_full_name
, make_number (256)),
12640 Fcons (Fcons (lispy_full_name
,
12641 make_number (fontp
->size
)),
12643 XCDR (dpyinfo
->name_list_element
));
12646 /* The slot `encoding' specifies how to map a character
12647 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
12648 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
12649 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
12650 2:0xA020..0xFF7F). For the moment, we don't know which charset
12651 uses this font. So, we set information in fontp->encoding[1]
12652 which is never used by any charset. If mapping can't be
12653 decided, set FONT_ENCODING_NOT_DECIDED. */
12655 = (font
->max_byte1
== 0
12657 ? (font
->min_char_or_byte2
< 0x80
12658 ? (font
->max_char_or_byte2
< 0x80
12659 ? 0 /* 0x20..0x7F */
12660 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
12661 : 1) /* 0xA0..0xFF */
12663 : (font
->min_byte1
< 0x80
12664 ? (font
->max_byte1
< 0x80
12665 ? (font
->min_char_or_byte2
< 0x80
12666 ? (font
->max_char_or_byte2
< 0x80
12667 ? 0 /* 0x2020..0x7F7F */
12668 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
12669 : 3) /* 0x20A0..0x7FFF */
12670 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
12671 : (font
->min_char_or_byte2
< 0x80
12672 ? (font
->max_char_or_byte2
< 0x80
12673 ? 2 /* 0xA020..0xFF7F */
12674 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
12675 : 1))); /* 0xA0A0..0xFFFF */
12677 fontp
->baseline_offset
12678 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
12679 ? (long) value
: 0);
12680 fontp
->relative_compose
12681 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
12682 ? (long) value
: 0);
12683 fontp
->default_ascent
12684 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
12685 ? (long) value
: 0);
12687 /* Set global flag fonts_changed_p to non-zero if the font loaded
12688 has a character with a smaller width than any other character
12689 before, or if the font loaded has a smalle>r height than any
12690 other font loaded before. If this happens, it will make a
12691 glyph matrix reallocation necessary. */
12692 fonts_changed_p
= x_compute_min_glyph_bounds (f
);
12699 /* Return a pointer to struct font_info of a font named FONTNAME for
12700 frame F. If no such font is loaded, return NULL. */
12703 x_query_font (f
, fontname
)
12705 register char *fontname
;
12707 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12710 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12711 if (dpyinfo
->font_table
[i
].name
12712 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
12713 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
12714 return (dpyinfo
->font_table
+ i
);
12719 /* Find a CCL program for a font specified by FONTP, and set the member
12720 `encoder' of the structure. */
12723 x_find_ccl_program (fontp
)
12724 struct font_info
*fontp
;
12726 Lisp_Object list
, elt
;
12728 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
12732 && STRINGP (XCAR (elt
))
12733 && (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
12739 struct ccl_program
*ccl
12740 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
12742 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
12745 fontp
->font_encoder
= ccl
;
12751 /***********************************************************************
12753 ***********************************************************************/
12755 #ifdef USE_X_TOOLKIT
12756 static XrmOptionDescRec emacs_options
[] = {
12757 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
12758 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
12760 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
12761 XrmoptionSepArg
, NULL
},
12762 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
12764 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
12765 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
12766 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
12767 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
12768 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
12769 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
12770 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
12772 #endif /* USE_X_TOOLKIT */
12774 static int x_initialized
;
12776 #ifdef MULTI_KBOARD
12777 /* Test whether two display-name strings agree up to the dot that separates
12778 the screen number from the server number. */
12780 same_x_server (name1
, name2
)
12781 char *name1
, *name2
;
12783 int seen_colon
= 0;
12784 unsigned char *system_name
= XSTRING (Vsystem_name
)->data
;
12785 int system_name_length
= strlen (system_name
);
12786 int length_until_period
= 0;
12788 while (system_name
[length_until_period
] != 0
12789 && system_name
[length_until_period
] != '.')
12790 length_until_period
++;
12792 /* Treat `unix' like an empty host name. */
12793 if (! strncmp (name1
, "unix:", 5))
12795 if (! strncmp (name2
, "unix:", 5))
12797 /* Treat this host's name like an empty host name. */
12798 if (! strncmp (name1
, system_name
, system_name_length
)
12799 && name1
[system_name_length
] == ':')
12800 name1
+= system_name_length
;
12801 if (! strncmp (name2
, system_name
, system_name_length
)
12802 && name2
[system_name_length
] == ':')
12803 name2
+= system_name_length
;
12804 /* Treat this host's domainless name like an empty host name. */
12805 if (! strncmp (name1
, system_name
, length_until_period
)
12806 && name1
[length_until_period
] == ':')
12807 name1
+= length_until_period
;
12808 if (! strncmp (name2
, system_name
, length_until_period
)
12809 && name2
[length_until_period
] == ':')
12810 name2
+= length_until_period
;
12812 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
12816 if (seen_colon
&& *name1
== '.')
12820 && (*name1
== '.' || *name1
== '\0')
12821 && (*name2
== '.' || *name2
== '\0'));
12825 struct x_display_info
*
12826 x_term_init (display_name
, xrm_option
, resource_name
)
12827 Lisp_Object display_name
;
12829 char *resource_name
;
12833 struct x_display_info
*dpyinfo
;
12838 if (!x_initialized
)
12844 #ifdef USE_X_TOOLKIT
12845 /* weiner@footloose.sps.mot.com reports that this causes
12847 X protocol error: BadAtom (invalid Atom parameter)
12848 on protocol request 18skiloaf.
12849 So let's not use it until R6. */
12850 #ifdef HAVE_X11XTR6
12851 XtSetLanguageProc (NULL
, NULL
, NULL
);
12862 argv
[argc
++] = "-xrm";
12863 argv
[argc
++] = xrm_option
;
12865 dpy
= XtOpenDisplay (Xt_app_con
, XSTRING (display_name
)->data
,
12866 resource_name
, EMACS_CLASS
,
12867 emacs_options
, XtNumber (emacs_options
),
12870 #ifdef HAVE_X11XTR6
12871 /* I think this is to compensate for XtSetLanguageProc. */
12876 #else /* not USE_X_TOOLKIT */
12878 XSetLocaleModifiers ("");
12880 dpy
= XOpenDisplay (XSTRING (display_name
)->data
);
12881 #endif /* not USE_X_TOOLKIT */
12883 /* Detect failure. */
12890 /* We have definitely succeeded. Record the new connection. */
12892 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
12894 #ifdef MULTI_KBOARD
12896 struct x_display_info
*share
;
12899 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
12900 share
= share
->next
, tail
= XCDR (tail
))
12901 if (same_x_server (XSTRING (XCAR (XCAR (tail
)))->data
,
12902 XSTRING (display_name
)->data
))
12905 dpyinfo
->kboard
= share
->kboard
;
12908 dpyinfo
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
12909 init_kboard (dpyinfo
->kboard
);
12910 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
12912 char *vendor
= ServerVendor (dpy
);
12914 dpyinfo
->kboard
->Vsystem_key_alist
12915 = call1 (Qvendor_specific_keysyms
,
12916 build_string (vendor
? vendor
: ""));
12920 dpyinfo
->kboard
->next_kboard
= all_kboards
;
12921 all_kboards
= dpyinfo
->kboard
;
12922 /* Don't let the initial kboard remain current longer than necessary.
12923 That would cause problems if a file loaded on startup tries to
12924 prompt in the mini-buffer. */
12925 if (current_kboard
== initial_kboard
)
12926 current_kboard
= dpyinfo
->kboard
;
12928 dpyinfo
->kboard
->reference_count
++;
12932 /* Put this display on the chain. */
12933 dpyinfo
->next
= x_display_list
;
12934 x_display_list
= dpyinfo
;
12936 /* Put it on x_display_name_list as well, to keep them parallel. */
12937 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
12938 x_display_name_list
);
12939 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
12941 dpyinfo
->display
= dpy
;
12944 XSetAfterFunction (x_current_display
, x_trace_wire
);
12948 = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name
))
12949 + STRING_BYTES (XSTRING (Vsystem_name
))
12951 sprintf (dpyinfo
->x_id_name
, "%s@%s",
12952 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
12954 /* Figure out which modifier bits mean what. */
12955 x_find_modifier_meanings (dpyinfo
);
12957 /* Get the scroll bar cursor. */
12958 dpyinfo
->vertical_scroll_bar_cursor
12959 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
12961 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
12962 resource_name
, EMACS_CLASS
);
12963 #ifdef HAVE_XRMSETDATABASE
12964 XrmSetDatabase (dpyinfo
->display
, xrdb
);
12966 dpyinfo
->display
->db
= xrdb
;
12968 /* Put the rdb where we can find it in a way that works on
12970 dpyinfo
->xrdb
= xrdb
;
12972 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
12973 DefaultScreen (dpyinfo
->display
));
12974 select_visual (dpyinfo
);
12975 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
12976 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
12977 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
12978 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
12979 dpyinfo
->grabbed
= 0;
12980 dpyinfo
->reference_count
= 0;
12981 dpyinfo
->icon_bitmap_id
= -1;
12982 dpyinfo
->font_table
= NULL
;
12983 dpyinfo
->n_fonts
= 0;
12984 dpyinfo
->font_table_size
= 0;
12985 dpyinfo
->bitmaps
= 0;
12986 dpyinfo
->bitmaps_size
= 0;
12987 dpyinfo
->bitmaps_last
= 0;
12988 dpyinfo
->scratch_cursor_gc
= 0;
12989 dpyinfo
->mouse_face_mouse_frame
= 0;
12990 dpyinfo
->mouse_face_deferred_gc
= 0;
12991 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
12992 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
12993 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
12994 dpyinfo
->mouse_face_window
= Qnil
;
12995 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
12996 dpyinfo
->mouse_face_defer
= 0;
12997 dpyinfo
->x_focus_frame
= 0;
12998 dpyinfo
->x_focus_event_frame
= 0;
12999 dpyinfo
->x_highlight_frame
= 0;
13000 dpyinfo
->image_cache
= make_image_cache ();
13002 /* See if a private colormap is requested. */
13003 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
13005 if (dpyinfo
->visual
->class == PseudoColor
)
13008 value
= display_x_get_resource (dpyinfo
,
13009 build_string ("privateColormap"),
13010 build_string ("PrivateColormap"),
13012 if (STRINGP (value
)
13013 && (!strcmp (XSTRING (value
)->data
, "true")
13014 || !strcmp (XSTRING (value
)->data
, "on")))
13015 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
13019 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
13020 dpyinfo
->visual
, AllocNone
);
13023 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
13024 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
13025 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
13026 dpyinfo
->resy
= pixels
* 25.4 / mm
;
13027 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
13028 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
13029 dpyinfo
->resx
= pixels
* 25.4 / mm
;
13032 dpyinfo
->Xatom_wm_protocols
13033 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
13034 dpyinfo
->Xatom_wm_take_focus
13035 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
13036 dpyinfo
->Xatom_wm_save_yourself
13037 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
13038 dpyinfo
->Xatom_wm_delete_window
13039 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
13040 dpyinfo
->Xatom_wm_change_state
13041 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
13042 dpyinfo
->Xatom_wm_configure_denied
13043 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
13044 dpyinfo
->Xatom_wm_window_moved
13045 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
13046 dpyinfo
->Xatom_editres
13047 = XInternAtom (dpyinfo
->display
, "Editres", False
);
13048 dpyinfo
->Xatom_CLIPBOARD
13049 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
13050 dpyinfo
->Xatom_TIMESTAMP
13051 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
13052 dpyinfo
->Xatom_TEXT
13053 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
13054 dpyinfo
->Xatom_COMPOUND_TEXT
13055 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
13056 dpyinfo
->Xatom_DELETE
13057 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
13058 dpyinfo
->Xatom_MULTIPLE
13059 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
13060 dpyinfo
->Xatom_INCR
13061 = XInternAtom (dpyinfo
->display
, "INCR", False
);
13062 dpyinfo
->Xatom_EMACS_TMP
13063 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
13064 dpyinfo
->Xatom_TARGETS
13065 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
13066 dpyinfo
->Xatom_NULL
13067 = XInternAtom (dpyinfo
->display
, "NULL", False
);
13068 dpyinfo
->Xatom_ATOM_PAIR
13069 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
13070 /* For properties of font. */
13071 dpyinfo
->Xatom_PIXEL_SIZE
13072 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
13073 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
13074 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
13075 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
13076 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
13077 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
13078 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
13080 /* Ghostscript support. */
13081 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
13082 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
13084 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
13087 dpyinfo
->cut_buffers_initialized
= 0;
13089 connection
= ConnectionNumber (dpyinfo
->display
);
13090 dpyinfo
->connection
= connection
;
13095 null_bits
[0] = 0x00;
13097 dpyinfo
->null_pixel
13098 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
13099 null_bits
, 1, 1, (long) 0, (long) 0,
13104 extern int gray_bitmap_width
, gray_bitmap_height
;
13105 extern unsigned char *gray_bitmap_bits
;
13107 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
13109 gray_bitmap_width
, gray_bitmap_height
,
13110 (unsigned long) 1, (unsigned long) 0, 1);
13114 xim_initialize (dpyinfo
, resource_name
);
13117 #ifdef subprocesses
13118 /* This is only needed for distinguishing keyboard and process input. */
13119 if (connection
!= 0)
13120 add_keyboard_wait_descriptor (connection
);
13123 #ifndef F_SETOWN_BUG
13125 #ifdef F_SETOWN_SOCK_NEG
13126 /* stdin is a socket here */
13127 fcntl (connection
, F_SETOWN
, -getpid ());
13128 #else /* ! defined (F_SETOWN_SOCK_NEG) */
13129 fcntl (connection
, F_SETOWN
, getpid ());
13130 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
13131 #endif /* ! defined (F_SETOWN) */
13132 #endif /* F_SETOWN_BUG */
13135 if (interrupt_input
)
13136 init_sigio (connection
);
13137 #endif /* ! defined (SIGIO) */
13140 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
13141 /* Make sure that we have a valid font for dialog boxes
13142 so that Xt does not crash. */
13144 Display
*dpy
= dpyinfo
->display
;
13145 XrmValue d
, fr
, to
;
13149 d
.addr
= (XPointer
)&dpy
;
13150 d
.size
= sizeof (Display
*);
13151 fr
.addr
= XtDefaultFont
;
13152 fr
.size
= sizeof (XtDefaultFont
);
13153 to
.size
= sizeof (Font
*);
13154 to
.addr
= (XPointer
)&font
;
13155 count
= x_catch_errors (dpy
);
13156 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
13158 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
13159 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
13160 x_uncatch_errors (dpy
, count
);
13165 /* See if we should run in synchronous mode. This is useful
13166 for debugging X code. */
13169 value
= display_x_get_resource (dpyinfo
,
13170 build_string ("synchronous"),
13171 build_string ("Synchronous"),
13173 if (STRINGP (value
)
13174 && (!strcmp (XSTRING (value
)->data
, "true")
13175 || !strcmp (XSTRING (value
)->data
, "on")))
13176 XSynchronize (dpyinfo
->display
, True
);
13184 /* Get rid of display DPYINFO, assuming all frames are already gone,
13185 and without sending any more commands to the X server. */
13188 x_delete_display (dpyinfo
)
13189 struct x_display_info
*dpyinfo
;
13191 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
13193 /* Discard this display from x_display_name_list and x_display_list.
13194 We can't use Fdelq because that can quit. */
13195 if (! NILP (x_display_name_list
)
13196 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
13197 x_display_name_list
= XCDR (x_display_name_list
);
13202 tail
= x_display_name_list
;
13203 while (CONSP (tail
) && CONSP (XCDR (tail
)))
13205 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
13207 XCDR (tail
) = XCDR (XCDR (tail
));
13210 tail
= XCDR (tail
);
13214 if (next_noop_dpyinfo
== dpyinfo
)
13215 next_noop_dpyinfo
= dpyinfo
->next
;
13217 if (x_display_list
== dpyinfo
)
13218 x_display_list
= dpyinfo
->next
;
13221 struct x_display_info
*tail
;
13223 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
13224 if (tail
->next
== dpyinfo
)
13225 tail
->next
= tail
->next
->next
;
13228 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
13229 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
13230 XrmDestroyDatabase (dpyinfo
->xrdb
);
13233 #ifdef MULTI_KBOARD
13234 if (--dpyinfo
->kboard
->reference_count
== 0)
13235 delete_kboard (dpyinfo
->kboard
);
13239 xim_close_dpy (dpyinfo
);
13242 xfree (dpyinfo
->font_table
);
13243 xfree (dpyinfo
->x_id_name
);
13247 /* Set up use of X before we make the first connection. */
13249 static struct redisplay_interface x_redisplay_interface
=
13254 x_clear_end_of_line
,
13256 x_after_update_window_line
,
13257 x_update_window_begin
,
13258 x_update_window_end
,
13261 x_get_glyph_overhangs
,
13262 x_fix_overlapping_area
13268 rif
= &x_redisplay_interface
;
13270 clear_frame_hook
= x_clear_frame
;
13271 ins_del_lines_hook
= x_ins_del_lines
;
13272 change_line_highlight_hook
= x_change_line_highlight
;
13273 delete_glyphs_hook
= x_delete_glyphs
;
13274 ring_bell_hook
= XTring_bell
;
13275 reset_terminal_modes_hook
= XTreset_terminal_modes
;
13276 set_terminal_modes_hook
= XTset_terminal_modes
;
13277 update_begin_hook
= x_update_begin
;
13278 update_end_hook
= x_update_end
;
13279 set_terminal_window_hook
= XTset_terminal_window
;
13280 read_socket_hook
= XTread_socket
;
13281 frame_up_to_date_hook
= XTframe_up_to_date
;
13282 reassert_line_highlight_hook
= XTreassert_line_highlight
;
13283 mouse_position_hook
= XTmouse_position
;
13284 frame_rehighlight_hook
= XTframe_rehighlight
;
13285 frame_raise_lower_hook
= XTframe_raise_lower
;
13286 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
13287 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
13288 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
13289 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
13290 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
13292 scroll_region_ok
= 1; /* we'll scroll partial frames */
13293 char_ins_del_ok
= 0; /* just as fast to write the line */
13294 line_ins_del_ok
= 1; /* we'll just blt 'em */
13295 fast_clear_end_of_line
= 1; /* X does this well */
13296 memory_below_frame
= 0; /* we don't remember what scrolls
13301 last_tool_bar_item
= -1;
13302 any_help_event_p
= 0;
13304 /* Try to use interrupt input; if we can't, then start polling. */
13305 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
13307 #ifdef USE_X_TOOLKIT
13308 XtToolkitInitialize ();
13309 Xt_app_con
= XtCreateApplicationContext ();
13310 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
13312 /* Install an asynchronous timer that processes Xt timeout events
13313 every 0.1s. This is necessary because some widget sets use
13314 timeouts internally, for example the LessTif menu bar, or the
13315 Xaw3d scroll bar. When Xt timouts aren't processed, these
13316 widgets don't behave normally. */
13318 EMACS_TIME interval
;
13319 EMACS_SET_SECS_USECS (interval
, 0, 100000);
13320 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
13324 #if USE_TOOLKIT_SCROLL_BARS
13325 xaw3d_arrow_scroll
= False
;
13326 xaw3d_pick_top
= True
;
13329 /* Note that there is no real way portable across R3/R4 to get the
13330 original error handler. */
13331 XSetErrorHandler (x_error_handler
);
13332 XSetIOErrorHandler (x_io_error_quitter
);
13334 /* Disable Window Change signals; they are handled by X events. */
13336 signal (SIGWINCH
, SIG_DFL
);
13337 #endif /* ! defined (SIGWINCH) */
13339 signal (SIGPIPE
, x_connection_signal
);
13346 staticpro (&x_error_message_string
);
13347 x_error_message_string
= Qnil
;
13349 staticpro (&x_display_name_list
);
13350 x_display_name_list
= Qnil
;
13352 staticpro (&last_mouse_scroll_bar
);
13353 last_mouse_scroll_bar
= Qnil
;
13355 staticpro (&Qvendor_specific_keysyms
);
13356 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
13358 staticpro (&last_mouse_press_frame
);
13359 last_mouse_press_frame
= Qnil
;
13361 staticpro (&help_echo
);
13363 staticpro (&previous_help_echo
);
13364 previous_help_echo
= Qnil
;
13366 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
13367 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
13368 For example, if a block cursor is over a tab, it will be drawn as\n\
13369 wide as that tab on the display.");
13370 x_stretch_cursor_p
= 0;
13372 DEFVAR_BOOL ("x-toolkit-scroll-bars-p", &x_toolkit_scroll_bars_p
,
13373 "If not nil, Emacs uses toolkit scroll bars.");
13374 #if USE_TOOLKIT_SCROLL_BARS
13375 x_toolkit_scroll_bars_p
= 1;
13377 x_toolkit_scroll_bars_p
= 0;
13380 staticpro (&last_mouse_motion_frame
);
13381 last_mouse_motion_frame
= Qnil
;
13384 #endif /* not HAVE_X_WINDOWS */