1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
27 Emacs separates the task of updating the display from code
28 modifying global state, e.g. buffer text. This way functions
29 operating on buffers don't also have to be concerned with updating
32 Updating the display is triggered by the Lisp interpreter when it
33 decides it's time to do it. This is done either automatically for
34 you as part of the interpreter's command loop or as the result of
35 calling Lisp functions like `sit-for'. The C function `redisplay'
36 in xdisp.c is the only entry into the inner redisplay code. (Or,
37 let's say almost---see the description of direct update
40 The following diagram shows how redisplay code is invoked. As you
41 can see, Lisp calls redisplay and vice versa. Under window systems
42 like X, some portions of the redisplay code are also called
43 asynchronously during mouse movement or expose events. It is very
44 important that these code parts do NOT use the C library (malloc,
45 free) because many C libraries under Unix are not reentrant. They
46 may also NOT call functions of the Lisp interpreter which could
47 change the interpreter's state. If you don't follow these rules,
48 you will encounter bugs which are very hard to explain.
50 (Direct functions, see below)
51 direct_output_for_insert,
52 direct_forward_char (dispnew.c)
53 +---------------------------------+
56 +--------------+ redisplay +----------------+
57 | Lisp machine |---------------->| Redisplay code |<--+
58 +--------------+ (xdisp.c) +----------------+ |
60 +----------------------------------+ |
61 Don't use this path when called |
64 expose_window (asynchronous) |
66 X expose events -----+
68 What does redisplay do? Obviously, it has to figure out somehow what
69 has been changed since the last time the display has been updated,
70 and to make these changes visible. Preferably it would do that in
71 a moderately intelligent way, i.e. fast.
73 Changes in buffer text can be deduced from window and buffer
74 structures, and from some global variables like `beg_unchanged' and
75 `end_unchanged'. The contents of the display are additionally
76 recorded in a `glyph matrix', a two-dimensional matrix of glyph
77 structures. Each row in such a matrix corresponds to a line on the
78 display, and each glyph in a row corresponds to a column displaying
79 a character, an image, or what else. This matrix is called the
80 `current glyph matrix' or `current matrix' in redisplay
83 For buffer parts that have been changed since the last update, a
84 second glyph matrix is constructed, the so called `desired glyph
85 matrix' or short `desired matrix'. Current and desired matrix are
86 then compared to find a cheap way to update the display, e.g. by
87 reusing part of the display by scrolling lines.
92 You will find a lot of redisplay optimizations when you start
93 looking at the innards of redisplay. The overall goal of all these
94 optimizations is to make redisplay fast because it is done
97 Two optimizations are not found in xdisp.c. These are the direct
98 operations mentioned above. As the name suggests they follow a
99 different principle than the rest of redisplay. Instead of
100 building a desired matrix and then comparing it with the current
101 display, they perform their actions directly on the display and on
104 One direct operation updates the display after one character has
105 been entered. The other one moves the cursor by one position
106 forward or backward. You find these functions under the names
107 `direct_output_for_insert' and `direct_output_forward_char' in
113 Desired matrices are always built per Emacs window. The function
114 `display_line' is the central function to look at if you are
115 interested. It constructs one row in a desired matrix given an
116 iterator structure containing both a buffer position and a
117 description of the environment in which the text is to be
118 displayed. But this is too early, read on.
120 Characters and pixmaps displayed for a range of buffer text depend
121 on various settings of buffers and windows, on overlays and text
122 properties, on display tables, on selective display. The good news
123 is that all this hairy stuff is hidden behind a small set of
124 interface functions taking an iterator structure (struct it)
127 Iteration over things to be displayed is then simple. It is
128 started by initializing an iterator with a call to init_iterator.
129 Calls to get_next_display_element fill the iterator structure with
130 relevant information about the next thing to display. Calls to
131 set_iterator_to_next move the iterator to the next thing.
133 Besides this, an iterator also contains information about the
134 display environment in which glyphs for display elements are to be
135 produced. It has fields for the width and height of the display,
136 the information whether long lines are truncated or continued, a
137 current X and Y position, and lots of other stuff you can better
140 Glyphs in a desired matrix are normally constructed in a loop
141 calling get_next_display_element and then produce_glyphs. The call
142 to produce_glyphs will fill the iterator structure with pixel
143 information about the element being displayed and at the same time
144 produce glyphs for it. If the display element fits on the line
145 being displayed, set_iterator_to_next is called next, otherwise the
146 glyphs produced are discarded.
151 That just couldn't be all, could it? What about terminal types not
152 supporting operations on sub-windows of the screen? To update the
153 display on such a terminal, window-based glyph matrices are not
154 well suited. To be able to reuse part of the display (scrolling
155 lines up and down), we must instead have a view of the whole
156 screen. This is what `frame matrices' are for. They are a trick.
158 Frames on terminals like above have a glyph pool. Windows on such
159 a frame sub-allocate their glyph memory from their frame's glyph
160 pool. The frame itself is given its own glyph matrices. By
161 coincidence---or maybe something else---rows in window glyph
162 matrices are slices of corresponding rows in frame matrices. Thus
163 writing to window matrices implicitly updates a frame matrix which
164 provides us with the view of the whole screen that we originally
165 wanted to have without having to move many bytes around. To be
166 honest, there is a little bit more done, but not much more. If you
167 plan to extend that code, take a look at dispnew.c. The function
168 build_frame_matrix is a good starting point. */
174 #include "keyboard.h"
177 #include "termchar.h"
178 #include "dispextern.h"
180 #include "character.h"
183 #include "commands.h"
187 #include "termhooks.h"
188 #include "intervals.h"
191 #include "region-cache.h"
193 #include "blockinput.h"
195 #ifdef HAVE_X_WINDOWS
205 #ifdef HAVE_WINDOW_SYSTEM
206 #ifdef USE_FONT_BACKEND
208 #endif /* USE_FONT_BACKEND */
209 #endif /* HAVE_WINDOW_SYSTEM */
211 #ifndef FRAME_X_OUTPUT
212 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
215 #define INFINITY 10000000
217 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
219 extern void set_frame_menubar
P_ ((struct frame
*f
, int, int));
220 extern int pending_menu_activation
;
223 extern int interrupt_input
;
224 extern int command_loop_level
;
226 extern Lisp_Object do_mouse_tracking
;
228 extern int minibuffer_auto_raise
;
229 extern Lisp_Object Vminibuffer_list
;
231 extern Lisp_Object Qface
;
232 extern Lisp_Object Qmode_line
, Qmode_line_inactive
, Qheader_line
;
234 extern Lisp_Object Voverriding_local_map
;
235 extern Lisp_Object Voverriding_local_map_menu_flag
;
236 extern Lisp_Object Qmenu_item
;
237 extern Lisp_Object Qwhen
;
238 extern Lisp_Object Qhelp_echo
;
240 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
241 Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
242 Lisp_Object Qredisplay_end_trigger_functions
, Vredisplay_end_trigger_functions
;
243 Lisp_Object Qinhibit_point_motion_hooks
;
244 Lisp_Object QCeval
, QCfile
, QCdata
, QCpropertize
;
245 Lisp_Object Qfontified
;
246 Lisp_Object Qgrow_only
;
247 Lisp_Object Qinhibit_eval_during_redisplay
;
248 Lisp_Object Qbuffer_position
, Qposition
, Qobject
;
251 Lisp_Object Qbar
, Qhbar
, Qbox
, Qhollow
;
254 Lisp_Object Qarrow
, Qhand
, Qtext
;
256 Lisp_Object Qrisky_local_variable
;
258 /* Holds the list (error). */
259 Lisp_Object list_of_error
;
261 /* Functions called to fontify regions of text. */
263 Lisp_Object Vfontification_functions
;
264 Lisp_Object Qfontification_functions
;
266 /* Non-nil means automatically select any window when the mouse
267 cursor moves into it. */
268 Lisp_Object Vmouse_autoselect_window
;
270 /* Non-zero means draw tool bar buttons raised when the mouse moves
273 int auto_raise_tool_bar_buttons_p
;
275 /* Non-zero means to reposition window if cursor line is only partially visible. */
277 int make_cursor_line_fully_visible_p
;
279 /* Margin below tool bar in pixels. 0 or nil means no margin.
280 If value is `internal-border-width' or `border-width',
281 the corresponding frame parameter is used. */
283 Lisp_Object Vtool_bar_border
;
285 /* Margin around tool bar buttons in pixels. */
287 Lisp_Object Vtool_bar_button_margin
;
289 /* Thickness of shadow to draw around tool bar buttons. */
291 EMACS_INT tool_bar_button_relief
;
293 /* Non-nil means automatically resize tool-bars so that all tool-bar
294 items are visible, and no blank lines remain.
296 If value is `grow-only', only make tool-bar bigger. */
298 Lisp_Object Vauto_resize_tool_bars
;
300 /* Non-zero means draw block and hollow cursor as wide as the glyph
301 under it. For example, if a block cursor is over a tab, it will be
302 drawn as wide as that tab on the display. */
304 int x_stretch_cursor_p
;
306 /* Non-nil means don't actually do any redisplay. */
308 Lisp_Object Vinhibit_redisplay
, Qinhibit_redisplay
;
310 /* Non-zero means Lisp evaluation during redisplay is inhibited. */
312 int inhibit_eval_during_redisplay
;
314 /* Names of text properties relevant for redisplay. */
316 Lisp_Object Qdisplay
;
317 extern Lisp_Object Qface
, Qinvisible
, Qwidth
;
319 /* Symbols used in text property values. */
321 Lisp_Object Vdisplay_pixels_per_inch
;
322 Lisp_Object Qspace
, QCalign_to
, QCrelative_width
, QCrelative_height
;
323 Lisp_Object Qleft_margin
, Qright_margin
, Qspace_width
, Qraise
;
326 Lisp_Object Qmargin
, Qpointer
;
327 Lisp_Object Qline_height
;
328 extern Lisp_Object Qheight
;
329 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
330 extern Lisp_Object Qscroll_bar
;
331 extern Lisp_Object Qcursor
;
333 /* Non-nil means highlight trailing whitespace. */
335 Lisp_Object Vshow_trailing_whitespace
;
337 /* Non-nil means escape non-break space and hyphens. */
339 Lisp_Object Vnobreak_char_display
;
341 #ifdef HAVE_WINDOW_SYSTEM
342 extern Lisp_Object Voverflow_newline_into_fringe
;
344 /* Test if overflow newline into fringe. Called with iterator IT
345 at or past right window margin, and with IT->current_x set. */
347 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) \
348 (!NILP (Voverflow_newline_into_fringe) \
349 && FRAME_WINDOW_P (it->f) \
350 && WINDOW_RIGHT_FRINGE_WIDTH (it->w) > 0 \
351 && it->current_x == it->last_visible_x)
353 #endif /* HAVE_WINDOW_SYSTEM */
355 /* Non-nil means show the text cursor in void text areas
356 i.e. in blank areas after eol and eob. This used to be
357 the default in 21.3. */
359 Lisp_Object Vvoid_text_area_pointer
;
361 /* Name of the face used to highlight trailing whitespace. */
363 Lisp_Object Qtrailing_whitespace
;
365 /* Name and number of the face used to highlight escape glyphs. */
367 Lisp_Object Qescape_glyph
;
369 /* Name and number of the face used to highlight non-breaking spaces. */
371 Lisp_Object Qnobreak_space
;
373 /* The symbol `image' which is the car of the lists used to represent
378 /* The image map types. */
379 Lisp_Object QCmap
, QCpointer
;
380 Lisp_Object Qrect
, Qcircle
, Qpoly
;
382 /* Non-zero means print newline to stdout before next mini-buffer
385 int noninteractive_need_newline
;
387 /* Non-zero means print newline to message log before next message. */
389 static int message_log_need_newline
;
391 /* Three markers that message_dolog uses.
392 It could allocate them itself, but that causes trouble
393 in handling memory-full errors. */
394 static Lisp_Object message_dolog_marker1
;
395 static Lisp_Object message_dolog_marker2
;
396 static Lisp_Object message_dolog_marker3
;
398 /* The buffer position of the first character appearing entirely or
399 partially on the line of the selected window which contains the
400 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
401 redisplay optimization in redisplay_internal. */
403 static struct text_pos this_line_start_pos
;
405 /* Number of characters past the end of the line above, including the
406 terminating newline. */
408 static struct text_pos this_line_end_pos
;
410 /* The vertical positions and the height of this line. */
412 static int this_line_vpos
;
413 static int this_line_y
;
414 static int this_line_pixel_height
;
416 /* X position at which this display line starts. Usually zero;
417 negative if first character is partially visible. */
419 static int this_line_start_x
;
421 /* Buffer that this_line_.* variables are referring to. */
423 static struct buffer
*this_line_buffer
;
425 /* Nonzero means truncate lines in all windows less wide than the
428 int truncate_partial_width_windows
;
430 /* A flag to control how to display unibyte 8-bit character. */
432 int unibyte_display_via_language_environment
;
434 /* Nonzero means we have more than one non-mini-buffer-only frame.
435 Not guaranteed to be accurate except while parsing
436 frame-title-format. */
440 Lisp_Object Vglobal_mode_string
;
443 /* List of variables (symbols) which hold markers for overlay arrows.
444 The symbols on this list are examined during redisplay to determine
445 where to display overlay arrows. */
447 Lisp_Object Voverlay_arrow_variable_list
;
449 /* Marker for where to display an arrow on top of the buffer text. */
451 Lisp_Object Voverlay_arrow_position
;
453 /* String to display for the arrow. Only used on terminal frames. */
455 Lisp_Object Voverlay_arrow_string
;
457 /* Values of those variables at last redisplay are stored as
458 properties on `overlay-arrow-position' symbol. However, if
459 Voverlay_arrow_position is a marker, last-arrow-position is its
460 numerical position. */
462 Lisp_Object Qlast_arrow_position
, Qlast_arrow_string
;
464 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
465 properties on a symbol in overlay-arrow-variable-list. */
467 Lisp_Object Qoverlay_arrow_string
, Qoverlay_arrow_bitmap
;
469 /* Like mode-line-format, but for the title bar on a visible frame. */
471 Lisp_Object Vframe_title_format
;
473 /* Like mode-line-format, but for the title bar on an iconified frame. */
475 Lisp_Object Vicon_title_format
;
477 /* List of functions to call when a window's size changes. These
478 functions get one arg, a frame on which one or more windows' sizes
481 static Lisp_Object Vwindow_size_change_functions
;
483 Lisp_Object Qmenu_bar_update_hook
, Vmenu_bar_update_hook
;
485 /* Nonzero if an overlay arrow has been displayed in this window. */
487 static int overlay_arrow_seen
;
489 /* Nonzero means highlight the region even in nonselected windows. */
491 int highlight_nonselected_windows
;
493 /* If cursor motion alone moves point off frame, try scrolling this
494 many lines up or down if that will bring it back. */
496 static EMACS_INT scroll_step
;
498 /* Nonzero means scroll just far enough to bring point back on the
499 screen, when appropriate. */
501 static EMACS_INT scroll_conservatively
;
503 /* Recenter the window whenever point gets within this many lines of
504 the top or bottom of the window. This value is translated into a
505 pixel value by multiplying it with FRAME_LINE_HEIGHT, which means
506 that there is really a fixed pixel height scroll margin. */
508 EMACS_INT scroll_margin
;
510 /* Number of windows showing the buffer of the selected window (or
511 another buffer with the same base buffer). keyboard.c refers to
516 /* Vector containing glyphs for an ellipsis `...'. */
518 static Lisp_Object default_invis_vector
[3];
520 /* Zero means display the mode-line/header-line/menu-bar in the default face
521 (this slightly odd definition is for compatibility with previous versions
522 of emacs), non-zero means display them using their respective faces.
524 This variable is deprecated. */
526 int mode_line_inverse_video
;
528 /* Prompt to display in front of the mini-buffer contents. */
530 Lisp_Object minibuf_prompt
;
532 /* Width of current mini-buffer prompt. Only set after display_line
533 of the line that contains the prompt. */
535 int minibuf_prompt_width
;
537 /* This is the window where the echo area message was displayed. It
538 is always a mini-buffer window, but it may not be the same window
539 currently active as a mini-buffer. */
541 Lisp_Object echo_area_window
;
543 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
544 pushes the current message and the value of
545 message_enable_multibyte on the stack, the function restore_message
546 pops the stack and displays MESSAGE again. */
548 Lisp_Object Vmessage_stack
;
550 /* Nonzero means multibyte characters were enabled when the echo area
551 message was specified. */
553 int message_enable_multibyte
;
555 /* Nonzero if we should redraw the mode lines on the next redisplay. */
557 int update_mode_lines
;
559 /* Nonzero if window sizes or contents have changed since last
560 redisplay that finished. */
562 int windows_or_buffers_changed
;
564 /* Nonzero means a frame's cursor type has been changed. */
566 int cursor_type_changed
;
568 /* Nonzero after display_mode_line if %l was used and it displayed a
571 int line_number_displayed
;
573 /* Maximum buffer size for which to display line numbers. */
575 Lisp_Object Vline_number_display_limit
;
577 /* Line width to consider when repositioning for line number display. */
579 static EMACS_INT line_number_display_limit_width
;
581 /* Number of lines to keep in the message log buffer. t means
582 infinite. nil means don't log at all. */
584 Lisp_Object Vmessage_log_max
;
586 /* The name of the *Messages* buffer, a string. */
588 static Lisp_Object Vmessages_buffer_name
;
590 /* Current, index 0, and last displayed echo area message. Either
591 buffers from echo_buffers, or nil to indicate no message. */
593 Lisp_Object echo_area_buffer
[2];
595 /* The buffers referenced from echo_area_buffer. */
597 static Lisp_Object echo_buffer
[2];
599 /* A vector saved used in with_area_buffer to reduce consing. */
601 static Lisp_Object Vwith_echo_area_save_vector
;
603 /* Non-zero means display_echo_area should display the last echo area
604 message again. Set by redisplay_preserve_echo_area. */
606 static int display_last_displayed_message_p
;
608 /* Nonzero if echo area is being used by print; zero if being used by
611 int message_buf_print
;
613 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
615 Lisp_Object Qinhibit_menubar_update
;
616 int inhibit_menubar_update
;
618 /* When evaluating expressions from menu bar items (enable conditions,
619 for instance), this is the frame they are being processed for. */
621 Lisp_Object Vmenu_updating_frame
;
623 /* Maximum height for resizing mini-windows. Either a float
624 specifying a fraction of the available height, or an integer
625 specifying a number of lines. */
627 Lisp_Object Vmax_mini_window_height
;
629 /* Non-zero means messages should be displayed with truncated
630 lines instead of being continued. */
632 int message_truncate_lines
;
633 Lisp_Object Qmessage_truncate_lines
;
635 /* Set to 1 in clear_message to make redisplay_internal aware
636 of an emptied echo area. */
638 static int message_cleared_p
;
640 /* How to blink the default frame cursor off. */
641 Lisp_Object Vblink_cursor_alist
;
643 /* A scratch glyph row with contents used for generating truncation
644 glyphs. Also used in direct_output_for_insert. */
646 #define MAX_SCRATCH_GLYPHS 100
647 struct glyph_row scratch_glyph_row
;
648 static struct glyph scratch_glyphs
[MAX_SCRATCH_GLYPHS
];
650 /* Ascent and height of the last line processed by move_it_to. */
652 static int last_max_ascent
, last_height
;
654 /* Non-zero if there's a help-echo in the echo area. */
656 int help_echo_showing_p
;
658 /* If >= 0, computed, exact values of mode-line and header-line height
659 to use in the macros CURRENT_MODE_LINE_HEIGHT and
660 CURRENT_HEADER_LINE_HEIGHT. */
662 int current_mode_line_height
, current_header_line_height
;
664 /* The maximum distance to look ahead for text properties. Values
665 that are too small let us call compute_char_face and similar
666 functions too often which is expensive. Values that are too large
667 let us call compute_char_face and alike too often because we
668 might not be interested in text properties that far away. */
670 #define TEXT_PROP_DISTANCE_LIMIT 100
674 /* Variables to turn off display optimizations from Lisp. */
676 int inhibit_try_window_id
, inhibit_try_window_reusing
;
677 int inhibit_try_cursor_movement
;
679 /* Non-zero means print traces of redisplay if compiled with
682 int trace_redisplay_p
;
684 #endif /* GLYPH_DEBUG */
686 #ifdef DEBUG_TRACE_MOVE
687 /* Non-zero means trace with TRACE_MOVE to stderr. */
690 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
692 #define TRACE_MOVE(x) (void) 0
695 /* Non-zero means automatically scroll windows horizontally to make
698 int automatic_hscrolling_p
;
700 /* How close to the margin can point get before the window is scrolled
702 EMACS_INT hscroll_margin
;
704 /* How much to scroll horizontally when point is inside the above margin. */
705 Lisp_Object Vhscroll_step
;
707 /* The variable `resize-mini-windows'. If nil, don't resize
708 mini-windows. If t, always resize them to fit the text they
709 display. If `grow-only', let mini-windows grow only until they
712 Lisp_Object Vresize_mini_windows
;
714 /* Buffer being redisplayed -- for redisplay_window_error. */
716 struct buffer
*displayed_buffer
;
718 /* Space between overline and text. */
720 EMACS_INT overline_margin
;
722 /* Value returned from text property handlers (see below). */
727 HANDLED_RECOMPUTE_PROPS
,
728 HANDLED_OVERLAY_STRING_CONSUMED
,
732 /* A description of text properties that redisplay is interested
737 /* The name of the property. */
740 /* A unique index for the property. */
743 /* A handler function called to set up iterator IT from the property
744 at IT's current position. Value is used to steer handle_stop. */
745 enum prop_handled (*handler
) P_ ((struct it
*it
));
748 static enum prop_handled handle_face_prop
P_ ((struct it
*));
749 static enum prop_handled handle_invisible_prop
P_ ((struct it
*));
750 static enum prop_handled handle_display_prop
P_ ((struct it
*));
751 static enum prop_handled handle_composition_prop
P_ ((struct it
*));
752 static enum prop_handled handle_overlay_change
P_ ((struct it
*));
753 static enum prop_handled handle_fontified_prop
P_ ((struct it
*));
754 static enum prop_handled handle_auto_composed_prop
P_ ((struct it
*));
756 /* Properties handled by iterators. */
758 static struct props it_props
[] =
760 {&Qfontified
, FONTIFIED_PROP_IDX
, handle_fontified_prop
},
761 /* Handle `face' before `display' because some sub-properties of
762 `display' need to know the face. */
763 {&Qface
, FACE_PROP_IDX
, handle_face_prop
},
764 {&Qdisplay
, DISPLAY_PROP_IDX
, handle_display_prop
},
765 {&Qinvisible
, INVISIBLE_PROP_IDX
, handle_invisible_prop
},
766 {&Qauto_composed
, AUTO_COMPOSED_PROP_IDX
, handle_auto_composed_prop
},
767 {&Qcomposition
, COMPOSITION_PROP_IDX
, handle_composition_prop
},
771 /* Value is the position described by X. If X is a marker, value is
772 the marker_position of X. Otherwise, value is X. */
774 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
776 /* Enumeration returned by some move_it_.* functions internally. */
780 /* Not used. Undefined value. */
783 /* Move ended at the requested buffer position or ZV. */
784 MOVE_POS_MATCH_OR_ZV
,
786 /* Move ended at the requested X pixel position. */
789 /* Move within a line ended at the end of a line that must be
793 /* Move within a line ended at the end of a line that would
794 be displayed truncated. */
797 /* Move within a line ended at a line end. */
801 /* This counter is used to clear the face cache every once in a while
802 in redisplay_internal. It is incremented for each redisplay.
803 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
806 #define CLEAR_FACE_CACHE_COUNT 500
807 static int clear_face_cache_count
;
809 /* Similarly for the image cache. */
811 #ifdef HAVE_WINDOW_SYSTEM
812 #define CLEAR_IMAGE_CACHE_COUNT 101
813 static int clear_image_cache_count
;
816 /* Non-zero while redisplay_internal is in progress. */
820 /* Non-zero means don't free realized faces. Bound while freeing
821 realized faces is dangerous because glyph matrices might still
824 int inhibit_free_realized_faces
;
825 Lisp_Object Qinhibit_free_realized_faces
;
827 /* If a string, XTread_socket generates an event to display that string.
828 (The display is done in read_char.) */
830 Lisp_Object help_echo_string
;
831 Lisp_Object help_echo_window
;
832 Lisp_Object help_echo_object
;
835 /* Temporary variable for XTread_socket. */
837 Lisp_Object previous_help_echo_string
;
839 /* Null glyph slice */
841 static struct glyph_slice null_glyph_slice
= { 0, 0, 0, 0 };
844 /* Function prototypes. */
846 static void setup_for_ellipsis
P_ ((struct it
*, int));
847 static void mark_window_display_accurate_1
P_ ((struct window
*, int));
848 static int single_display_spec_string_p
P_ ((Lisp_Object
, Lisp_Object
));
849 static int display_prop_string_p
P_ ((Lisp_Object
, Lisp_Object
));
850 static int cursor_row_p
P_ ((struct window
*, struct glyph_row
*));
851 static int redisplay_mode_lines
P_ ((Lisp_Object
, int));
852 static char *decode_mode_spec_coding
P_ ((Lisp_Object
, char *, int));
855 static int invisible_text_between_p
P_ ((struct it
*, int, int));
858 static void pint2str
P_ ((char *, int, int));
859 static void pint2hrstr
P_ ((char *, int, int));
860 static struct text_pos run_window_scroll_functions
P_ ((Lisp_Object
,
862 static void reconsider_clip_changes
P_ ((struct window
*, struct buffer
*));
863 static int text_outside_line_unchanged_p
P_ ((struct window
*, int, int));
864 static void store_mode_line_noprop_char
P_ ((char));
865 static int store_mode_line_noprop
P_ ((const unsigned char *, int, int));
866 static void x_consider_frame_title
P_ ((Lisp_Object
));
867 static void handle_stop
P_ ((struct it
*));
868 static int tool_bar_lines_needed
P_ ((struct frame
*, int *));
869 static int single_display_spec_intangible_p
P_ ((Lisp_Object
));
870 static void ensure_echo_area_buffers
P_ ((void));
871 static Lisp_Object unwind_with_echo_area_buffer
P_ ((Lisp_Object
));
872 static Lisp_Object with_echo_area_buffer_unwind_data
P_ ((struct window
*));
873 static int with_echo_area_buffer
P_ ((struct window
*, int,
874 int (*) (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
),
875 EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
876 static void clear_garbaged_frames
P_ ((void));
877 static int current_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
878 static int truncate_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
879 static int set_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
880 static int display_echo_area
P_ ((struct window
*));
881 static int display_echo_area_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
882 static int resize_mini_window_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
883 static Lisp_Object unwind_redisplay
P_ ((Lisp_Object
));
884 static int string_char_and_length
P_ ((const unsigned char *, int, int *));
885 static struct text_pos display_prop_end
P_ ((struct it
*, Lisp_Object
,
887 static int compute_window_start_on_continuation_line
P_ ((struct window
*));
888 static Lisp_Object safe_eval_handler
P_ ((Lisp_Object
));
889 static void insert_left_trunc_glyphs
P_ ((struct it
*));
890 static struct glyph_row
*get_overlay_arrow_glyph_row
P_ ((struct window
*,
892 static void extend_face_to_end_of_line
P_ ((struct it
*));
893 static int append_space_for_newline
P_ ((struct it
*, int));
894 static int cursor_row_fully_visible_p
P_ ((struct window
*, int, int));
895 static int try_scrolling
P_ ((Lisp_Object
, int, EMACS_INT
, EMACS_INT
, int, int));
896 static int try_cursor_movement
P_ ((Lisp_Object
, struct text_pos
, int *));
897 static int trailing_whitespace_p
P_ ((int));
898 static int message_log_check_duplicate
P_ ((int, int, int, int));
899 static void push_it
P_ ((struct it
*));
900 static void pop_it
P_ ((struct it
*));
901 static void sync_frame_with_window_matrix_rows
P_ ((struct window
*));
902 static void select_frame_for_redisplay
P_ ((Lisp_Object
));
903 static void redisplay_internal
P_ ((int));
904 static int echo_area_display
P_ ((int));
905 static void redisplay_windows
P_ ((Lisp_Object
));
906 static void redisplay_window
P_ ((Lisp_Object
, int));
907 static Lisp_Object
redisplay_window_error ();
908 static Lisp_Object redisplay_window_0
P_ ((Lisp_Object
));
909 static Lisp_Object redisplay_window_1
P_ ((Lisp_Object
));
910 static int update_menu_bar
P_ ((struct frame
*, int, int));
911 static int try_window_reusing_current_matrix
P_ ((struct window
*));
912 static int try_window_id
P_ ((struct window
*));
913 static int display_line
P_ ((struct it
*));
914 static int display_mode_lines
P_ ((struct window
*));
915 static int display_mode_line
P_ ((struct window
*, enum face_id
, Lisp_Object
));
916 static int display_mode_element
P_ ((struct it
*, int, int, int, Lisp_Object
, Lisp_Object
, int));
917 static int store_mode_line_string
P_ ((char *, Lisp_Object
, int, int, int, Lisp_Object
));
918 static char *decode_mode_spec
P_ ((struct window
*, int, int, int, int *));
919 static void display_menu_bar
P_ ((struct window
*));
920 static int display_count_lines
P_ ((int, int, int, int, int *));
921 static int display_string
P_ ((unsigned char *, Lisp_Object
, Lisp_Object
,
922 int, int, struct it
*, int, int, int, int));
923 static void compute_line_metrics
P_ ((struct it
*));
924 static void run_redisplay_end_trigger_hook
P_ ((struct it
*));
925 static int get_overlay_strings
P_ ((struct it
*, int));
926 static int get_overlay_strings_1
P_ ((struct it
*, int, int));
927 static void next_overlay_string
P_ ((struct it
*));
928 static void reseat
P_ ((struct it
*, struct text_pos
, int));
929 static void reseat_1
P_ ((struct it
*, struct text_pos
, int));
930 static void back_to_previous_visible_line_start
P_ ((struct it
*));
931 void reseat_at_previous_visible_line_start
P_ ((struct it
*));
932 static void reseat_at_next_visible_line_start
P_ ((struct it
*, int));
933 static int next_element_from_ellipsis
P_ ((struct it
*));
934 static int next_element_from_display_vector
P_ ((struct it
*));
935 static int next_element_from_string
P_ ((struct it
*));
936 static int next_element_from_c_string
P_ ((struct it
*));
937 static int next_element_from_buffer
P_ ((struct it
*));
938 static int next_element_from_composition
P_ ((struct it
*));
939 static int next_element_from_image
P_ ((struct it
*));
940 static int next_element_from_stretch
P_ ((struct it
*));
941 static void load_overlay_strings
P_ ((struct it
*, int));
942 static int init_from_display_pos
P_ ((struct it
*, struct window
*,
943 struct display_pos
*));
944 static void reseat_to_string
P_ ((struct it
*, unsigned char *,
945 Lisp_Object
, int, int, int, int));
946 static enum move_it_result move_it_in_display_line_to
P_ ((struct it
*,
948 void move_it_vertically_backward
P_ ((struct it
*, int));
949 static void init_to_row_start
P_ ((struct it
*, struct window
*,
950 struct glyph_row
*));
951 static int init_to_row_end
P_ ((struct it
*, struct window
*,
952 struct glyph_row
*));
953 static void back_to_previous_line_start
P_ ((struct it
*));
954 static int forward_to_next_line_start
P_ ((struct it
*, int *));
955 static struct text_pos string_pos_nchars_ahead
P_ ((struct text_pos
,
957 static struct text_pos string_pos
P_ ((int, Lisp_Object
));
958 static struct text_pos c_string_pos
P_ ((int, unsigned char *, int));
959 static int number_of_chars
P_ ((unsigned char *, int));
960 static void compute_stop_pos
P_ ((struct it
*));
961 static void compute_string_pos
P_ ((struct text_pos
*, struct text_pos
,
963 static int face_before_or_after_it_pos
P_ ((struct it
*, int));
964 static int next_overlay_change
P_ ((int));
965 static int handle_single_display_spec
P_ ((struct it
*, Lisp_Object
,
966 Lisp_Object
, Lisp_Object
,
967 struct text_pos
*, int));
968 static int underlying_face_id
P_ ((struct it
*));
969 static int in_ellipses_for_invisible_text_p
P_ ((struct display_pos
*,
972 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
973 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
975 #ifdef HAVE_WINDOW_SYSTEM
977 static void update_tool_bar
P_ ((struct frame
*, int));
978 static void build_desired_tool_bar_string
P_ ((struct frame
*f
));
979 static int redisplay_tool_bar
P_ ((struct frame
*));
980 static void display_tool_bar_line
P_ ((struct it
*, int));
981 static void notice_overwritten_cursor
P_ ((struct window
*,
983 int, int, int, int));
987 #endif /* HAVE_WINDOW_SYSTEM */
990 /***********************************************************************
991 Window display dimensions
992 ***********************************************************************/
994 /* Return the bottom boundary y-position for text lines in window W.
995 This is the first y position at which a line cannot start.
996 It is relative to the top of the window.
998 This is the height of W minus the height of a mode line, if any. */
1001 window_text_bottom_y (w
)
1004 int height
= WINDOW_TOTAL_HEIGHT (w
);
1006 if (WINDOW_WANTS_MODELINE_P (w
))
1007 height
-= CURRENT_MODE_LINE_HEIGHT (w
);
1011 /* Return the pixel width of display area AREA of window W. AREA < 0
1012 means return the total width of W, not including fringes to
1013 the left and right of the window. */
1016 window_box_width (w
, area
)
1020 int cols
= XFASTINT (w
->total_cols
);
1023 if (!w
->pseudo_window_p
)
1025 cols
-= WINDOW_SCROLL_BAR_COLS (w
);
1027 if (area
== TEXT_AREA
)
1029 if (INTEGERP (w
->left_margin_cols
))
1030 cols
-= XFASTINT (w
->left_margin_cols
);
1031 if (INTEGERP (w
->right_margin_cols
))
1032 cols
-= XFASTINT (w
->right_margin_cols
);
1033 pixels
= -WINDOW_TOTAL_FRINGE_WIDTH (w
);
1035 else if (area
== LEFT_MARGIN_AREA
)
1037 cols
= (INTEGERP (w
->left_margin_cols
)
1038 ? XFASTINT (w
->left_margin_cols
) : 0);
1041 else if (area
== RIGHT_MARGIN_AREA
)
1043 cols
= (INTEGERP (w
->right_margin_cols
)
1044 ? XFASTINT (w
->right_margin_cols
) : 0);
1049 return cols
* WINDOW_FRAME_COLUMN_WIDTH (w
) + pixels
;
1053 /* Return the pixel height of the display area of window W, not
1054 including mode lines of W, if any. */
1057 window_box_height (w
)
1060 struct frame
*f
= XFRAME (w
->frame
);
1061 int height
= WINDOW_TOTAL_HEIGHT (w
);
1063 xassert (height
>= 0);
1065 /* Note: the code below that determines the mode-line/header-line
1066 height is essentially the same as that contained in the macro
1067 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
1068 the appropriate glyph row has its `mode_line_p' flag set,
1069 and if it doesn't, uses estimate_mode_line_height instead. */
1071 if (WINDOW_WANTS_MODELINE_P (w
))
1073 struct glyph_row
*ml_row
1074 = (w
->current_matrix
&& w
->current_matrix
->rows
1075 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
1077 if (ml_row
&& ml_row
->mode_line_p
)
1078 height
-= ml_row
->height
;
1080 height
-= estimate_mode_line_height (f
, CURRENT_MODE_LINE_FACE_ID (w
));
1083 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1085 struct glyph_row
*hl_row
1086 = (w
->current_matrix
&& w
->current_matrix
->rows
1087 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
1089 if (hl_row
&& hl_row
->mode_line_p
)
1090 height
-= hl_row
->height
;
1092 height
-= estimate_mode_line_height (f
, HEADER_LINE_FACE_ID
);
1095 /* With a very small font and a mode-line that's taller than
1096 default, we might end up with a negative height. */
1097 return max (0, height
);
1100 /* Return the window-relative coordinate of the left edge of display
1101 area AREA of window W. AREA < 0 means return the left edge of the
1102 whole window, to the right of the left fringe of W. */
1105 window_box_left_offset (w
, area
)
1111 if (w
->pseudo_window_p
)
1114 x
= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
1116 if (area
== TEXT_AREA
)
1117 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1118 + window_box_width (w
, LEFT_MARGIN_AREA
));
1119 else if (area
== RIGHT_MARGIN_AREA
)
1120 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1121 + window_box_width (w
, LEFT_MARGIN_AREA
)
1122 + window_box_width (w
, TEXT_AREA
)
1123 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1125 : WINDOW_RIGHT_FRINGE_WIDTH (w
)));
1126 else if (area
== LEFT_MARGIN_AREA
1127 && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1128 x
+= WINDOW_LEFT_FRINGE_WIDTH (w
);
1134 /* Return the window-relative coordinate of the right edge of display
1135 area AREA of window W. AREA < 0 means return the left edge of the
1136 whole window, to the left of the right fringe of W. */
1139 window_box_right_offset (w
, area
)
1143 return window_box_left_offset (w
, area
) + window_box_width (w
, area
);
1146 /* Return the frame-relative coordinate of the left edge of display
1147 area AREA of window W. AREA < 0 means return the left edge of the
1148 whole window, to the right of the left fringe of W. */
1151 window_box_left (w
, area
)
1155 struct frame
*f
= XFRAME (w
->frame
);
1158 if (w
->pseudo_window_p
)
1159 return FRAME_INTERNAL_BORDER_WIDTH (f
);
1161 x
= (WINDOW_LEFT_EDGE_X (w
)
1162 + window_box_left_offset (w
, area
));
1168 /* Return the frame-relative coordinate of the right edge of display
1169 area AREA of window W. AREA < 0 means return the left edge of the
1170 whole window, to the left of the right fringe of W. */
1173 window_box_right (w
, area
)
1177 return window_box_left (w
, area
) + window_box_width (w
, area
);
1180 /* Get the bounding box of the display area AREA of window W, without
1181 mode lines, in frame-relative coordinates. AREA < 0 means the
1182 whole window, not including the left and right fringes of
1183 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
1184 coordinates of the upper-left corner of the box. Return in
1185 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
1188 window_box (w
, area
, box_x
, box_y
, box_width
, box_height
)
1191 int *box_x
, *box_y
, *box_width
, *box_height
;
1194 *box_width
= window_box_width (w
, area
);
1196 *box_height
= window_box_height (w
);
1198 *box_x
= window_box_left (w
, area
);
1201 *box_y
= WINDOW_TOP_EDGE_Y (w
);
1202 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1203 *box_y
+= CURRENT_HEADER_LINE_HEIGHT (w
);
1208 /* Get the bounding box of the display area AREA of window W, without
1209 mode lines. AREA < 0 means the whole window, not including the
1210 left and right fringe of the window. Return in *TOP_LEFT_X
1211 and TOP_LEFT_Y the frame-relative pixel coordinates of the
1212 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
1213 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
1217 window_box_edges (w
, area
, top_left_x
, top_left_y
,
1218 bottom_right_x
, bottom_right_y
)
1221 int *top_left_x
, *top_left_y
, *bottom_right_x
, *bottom_right_y
;
1223 window_box (w
, area
, top_left_x
, top_left_y
, bottom_right_x
,
1225 *bottom_right_x
+= *top_left_x
;
1226 *bottom_right_y
+= *top_left_y
;
1231 /***********************************************************************
1233 ***********************************************************************/
1235 /* Return the bottom y-position of the line the iterator IT is in.
1236 This can modify IT's settings. */
1242 int line_height
= it
->max_ascent
+ it
->max_descent
;
1243 int line_top_y
= it
->current_y
;
1245 if (line_height
== 0)
1248 line_height
= last_height
;
1249 else if (IT_CHARPOS (*it
) < ZV
)
1251 move_it_by_lines (it
, 1, 1);
1252 line_height
= (it
->max_ascent
|| it
->max_descent
1253 ? it
->max_ascent
+ it
->max_descent
1258 struct glyph_row
*row
= it
->glyph_row
;
1260 /* Use the default character height. */
1261 it
->glyph_row
= NULL
;
1262 it
->what
= IT_CHARACTER
;
1265 PRODUCE_GLYPHS (it
);
1266 line_height
= it
->ascent
+ it
->descent
;
1267 it
->glyph_row
= row
;
1271 return line_top_y
+ line_height
;
1275 /* Return 1 if position CHARPOS is visible in window W.
1276 CHARPOS < 0 means return info about WINDOW_END position.
1277 If visible, set *X and *Y to pixel coordinates of top left corner.
1278 Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
1279 Set *ROWH and *VPOS to row's visible height and VPOS (row number). */
1282 pos_visible_p (w
, charpos
, x
, y
, rtop
, rbot
, rowh
, vpos
)
1284 int charpos
, *x
, *y
, *rtop
, *rbot
, *rowh
, *vpos
;
1287 struct text_pos top
;
1289 struct buffer
*old_buffer
= NULL
;
1294 if (XBUFFER (w
->buffer
) != current_buffer
)
1296 old_buffer
= current_buffer
;
1297 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1300 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1302 /* Compute exact mode line heights. */
1303 if (WINDOW_WANTS_MODELINE_P (w
))
1304 current_mode_line_height
1305 = display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID (w
),
1306 current_buffer
->mode_line_format
);
1308 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1309 current_header_line_height
1310 = display_mode_line (w
, HEADER_LINE_FACE_ID
,
1311 current_buffer
->header_line_format
);
1313 start_display (&it
, w
, top
);
1314 move_it_to (&it
, charpos
, -1, it
.last_visible_y
-1, -1,
1315 (charpos
>= 0 ? MOVE_TO_POS
: 0) | MOVE_TO_Y
);
1317 /* Note that we may overshoot because of invisible text. */
1318 if (charpos
>= 0 && IT_CHARPOS (it
) >= charpos
)
1320 int top_x
= it
.current_x
;
1321 int top_y
= it
.current_y
;
1322 int bottom_y
= (last_height
= 0, line_bottom_y (&it
));
1323 int window_top_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1325 if (top_y
< window_top_y
)
1326 visible_p
= bottom_y
> window_top_y
;
1327 else if (top_y
< it
.last_visible_y
)
1332 *y
= max (top_y
+ max (0, it
.max_ascent
- it
.ascent
), window_top_y
);
1333 *rtop
= max (0, window_top_y
- top_y
);
1334 *rbot
= max (0, bottom_y
- it
.last_visible_y
);
1335 *rowh
= max (0, (min (bottom_y
, it
.last_visible_y
)
1336 - max (top_y
, window_top_y
)));
1345 if (IT_CHARPOS (it
) < ZV
&& FETCH_BYTE (IT_BYTEPOS (it
)) != '\n')
1346 move_it_by_lines (&it
, 1, 0);
1347 if (charpos
< IT_CHARPOS (it
)
1348 || (it
.what
== IT_EOB
&& charpos
== IT_CHARPOS (it
)))
1351 move_it_to (&it2
, charpos
, -1, -1, -1, MOVE_TO_POS
);
1353 *y
= it2
.current_y
+ it2
.max_ascent
- it2
.ascent
;
1354 *rtop
= max (0, -it2
.current_y
);
1355 *rbot
= max (0, ((it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
)
1356 - it
.last_visible_y
));
1357 *rowh
= max (0, (min (it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
,
1359 - max (it2
.current_y
,
1360 WINDOW_HEADER_LINE_HEIGHT (w
))));
1366 set_buffer_internal_1 (old_buffer
);
1368 current_header_line_height
= current_mode_line_height
= -1;
1370 if (visible_p
&& XFASTINT (w
->hscroll
) > 0)
1371 *x
-= XFASTINT (w
->hscroll
) * WINDOW_FRAME_COLUMN_WIDTH (w
);
1374 /* Debugging code. */
1376 fprintf (stderr
, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1377 charpos
, w
->vscroll
, *x
, *y
, *rtop
, *rbot
, *rowh
, *vpos
);
1379 fprintf (stderr
, "-pv pt=%d vs=%d\n", charpos
, w
->vscroll
);
1386 /* Return the next character from STR which is MAXLEN bytes long.
1387 Return in *LEN the length of the character. This is like
1388 STRING_CHAR_AND_LENGTH but never returns an invalid character. If
1389 we find one, we return a `?', but with the length of the invalid
1393 string_char_and_length (str
, maxlen
, len
)
1394 const unsigned char *str
;
1399 c
= STRING_CHAR_AND_LENGTH (str
, maxlen
, *len
);
1400 if (!CHAR_VALID_P (c
, 1))
1401 /* We may not change the length here because other places in Emacs
1402 don't use this function, i.e. they silently accept invalid
1411 /* Given a position POS containing a valid character and byte position
1412 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1414 static struct text_pos
1415 string_pos_nchars_ahead (pos
, string
, nchars
)
1416 struct text_pos pos
;
1420 xassert (STRINGP (string
) && nchars
>= 0);
1422 if (STRING_MULTIBYTE (string
))
1424 int rest
= SBYTES (string
) - BYTEPOS (pos
);
1425 const unsigned char *p
= SDATA (string
) + BYTEPOS (pos
);
1430 string_char_and_length (p
, rest
, &len
);
1431 p
+= len
, rest
-= len
;
1432 xassert (rest
>= 0);
1434 BYTEPOS (pos
) += len
;
1438 SET_TEXT_POS (pos
, CHARPOS (pos
) + nchars
, BYTEPOS (pos
) + nchars
);
1444 /* Value is the text position, i.e. character and byte position,
1445 for character position CHARPOS in STRING. */
1447 static INLINE
struct text_pos
1448 string_pos (charpos
, string
)
1452 struct text_pos pos
;
1453 xassert (STRINGP (string
));
1454 xassert (charpos
>= 0);
1455 SET_TEXT_POS (pos
, charpos
, string_char_to_byte (string
, charpos
));
1460 /* Value is a text position, i.e. character and byte position, for
1461 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1462 means recognize multibyte characters. */
1464 static struct text_pos
1465 c_string_pos (charpos
, s
, multibyte_p
)
1470 struct text_pos pos
;
1472 xassert (s
!= NULL
);
1473 xassert (charpos
>= 0);
1477 int rest
= strlen (s
), len
;
1479 SET_TEXT_POS (pos
, 0, 0);
1482 string_char_and_length (s
, rest
, &len
);
1483 s
+= len
, rest
-= len
;
1484 xassert (rest
>= 0);
1486 BYTEPOS (pos
) += len
;
1490 SET_TEXT_POS (pos
, charpos
, charpos
);
1496 /* Value is the number of characters in C string S. MULTIBYTE_P
1497 non-zero means recognize multibyte characters. */
1500 number_of_chars (s
, multibyte_p
)
1508 int rest
= strlen (s
), len
;
1509 unsigned char *p
= (unsigned char *) s
;
1511 for (nchars
= 0; rest
> 0; ++nchars
)
1513 string_char_and_length (p
, rest
, &len
);
1514 rest
-= len
, p
+= len
;
1518 nchars
= strlen (s
);
1524 /* Compute byte position NEWPOS->bytepos corresponding to
1525 NEWPOS->charpos. POS is a known position in string STRING.
1526 NEWPOS->charpos must be >= POS.charpos. */
1529 compute_string_pos (newpos
, pos
, string
)
1530 struct text_pos
*newpos
, pos
;
1533 xassert (STRINGP (string
));
1534 xassert (CHARPOS (*newpos
) >= CHARPOS (pos
));
1536 if (STRING_MULTIBYTE (string
))
1537 *newpos
= string_pos_nchars_ahead (pos
, string
,
1538 CHARPOS (*newpos
) - CHARPOS (pos
));
1540 BYTEPOS (*newpos
) = CHARPOS (*newpos
);
1544 Return an estimation of the pixel height of mode or top lines on
1545 frame F. FACE_ID specifies what line's height to estimate. */
1548 estimate_mode_line_height (f
, face_id
)
1550 enum face_id face_id
;
1552 #ifdef HAVE_WINDOW_SYSTEM
1553 if (FRAME_WINDOW_P (f
))
1555 int height
= FONT_HEIGHT (FRAME_FONT (f
));
1557 /* This function is called so early when Emacs starts that the face
1558 cache and mode line face are not yet initialized. */
1559 if (FRAME_FACE_CACHE (f
))
1561 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1565 height
= FONT_HEIGHT (face
->font
);
1566 if (face
->box_line_width
> 0)
1567 height
+= 2 * face
->box_line_width
;
1578 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
1579 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
1580 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
1581 not force the value into range. */
1584 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
1586 register int pix_x
, pix_y
;
1588 NativeRectangle
*bounds
;
1592 #ifdef HAVE_WINDOW_SYSTEM
1593 if (FRAME_WINDOW_P (f
))
1595 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
1596 even for negative values. */
1598 pix_x
-= FRAME_COLUMN_WIDTH (f
) - 1;
1600 pix_y
-= FRAME_LINE_HEIGHT (f
) - 1;
1602 pix_x
= FRAME_PIXEL_X_TO_COL (f
, pix_x
);
1603 pix_y
= FRAME_PIXEL_Y_TO_LINE (f
, pix_y
);
1606 STORE_NATIVE_RECT (*bounds
,
1607 FRAME_COL_TO_PIXEL_X (f
, pix_x
),
1608 FRAME_LINE_TO_PIXEL_Y (f
, pix_y
),
1609 FRAME_COLUMN_WIDTH (f
) - 1,
1610 FRAME_LINE_HEIGHT (f
) - 1);
1616 else if (pix_x
> FRAME_TOTAL_COLS (f
))
1617 pix_x
= FRAME_TOTAL_COLS (f
);
1621 else if (pix_y
> FRAME_LINES (f
))
1622 pix_y
= FRAME_LINES (f
);
1632 /* Given HPOS/VPOS in the current matrix of W, return corresponding
1633 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
1634 can't tell the positions because W's display is not up to date,
1638 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
1641 int *frame_x
, *frame_y
;
1643 #ifdef HAVE_WINDOW_SYSTEM
1644 if (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w
))))
1648 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
1649 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
1651 if (display_completed
)
1653 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
1654 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1655 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
1661 hpos
+= glyph
->pixel_width
;
1665 /* If first glyph is partially visible, its first visible position is still 0. */
1677 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, hpos
);
1678 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, vpos
);
1689 #ifdef HAVE_WINDOW_SYSTEM
1691 /* Find the glyph under window-relative coordinates X/Y in window W.
1692 Consider only glyphs from buffer text, i.e. no glyphs from overlay
1693 strings. Return in *HPOS and *VPOS the row and column number of
1694 the glyph found. Return in *AREA the glyph area containing X.
1695 Value is a pointer to the glyph found or null if X/Y is not on
1696 text, or we can't tell because W's current matrix is not up to
1699 static struct glyph
*
1700 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, dx
, dy
, area
)
1703 int *hpos
, *vpos
, *dx
, *dy
, *area
;
1705 struct glyph
*glyph
, *end
;
1706 struct glyph_row
*row
= NULL
;
1709 /* Find row containing Y. Give up if some row is not enabled. */
1710 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
1712 row
= MATRIX_ROW (w
->current_matrix
, i
);
1713 if (!row
->enabled_p
)
1715 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
1722 /* Give up if Y is not in the window. */
1723 if (i
== w
->current_matrix
->nrows
)
1726 /* Get the glyph area containing X. */
1727 if (w
->pseudo_window_p
)
1734 if (x
< window_box_left_offset (w
, TEXT_AREA
))
1736 *area
= LEFT_MARGIN_AREA
;
1737 x0
= window_box_left_offset (w
, LEFT_MARGIN_AREA
);
1739 else if (x
< window_box_right_offset (w
, TEXT_AREA
))
1742 x0
= window_box_left_offset (w
, TEXT_AREA
) + min (row
->x
, 0);
1746 *area
= RIGHT_MARGIN_AREA
;
1747 x0
= window_box_left_offset (w
, RIGHT_MARGIN_AREA
);
1751 /* Find glyph containing X. */
1752 glyph
= row
->glyphs
[*area
];
1753 end
= glyph
+ row
->used
[*area
];
1755 while (glyph
< end
&& x
>= glyph
->pixel_width
)
1757 x
-= glyph
->pixel_width
;
1767 *dy
= y
- (row
->y
+ row
->ascent
- glyph
->ascent
);
1770 *hpos
= glyph
- row
->glyphs
[*area
];
1776 Convert frame-relative x/y to coordinates relative to window W.
1777 Takes pseudo-windows into account. */
1780 frame_to_window_pixel_xy (w
, x
, y
)
1784 if (w
->pseudo_window_p
)
1786 /* A pseudo-window is always full-width, and starts at the
1787 left edge of the frame, plus a frame border. */
1788 struct frame
*f
= XFRAME (w
->frame
);
1789 *x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
1790 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1794 *x
-= WINDOW_LEFT_EDGE_X (w
);
1795 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1800 Return in RECTS[] at most N clipping rectangles for glyph string S.
1801 Return the number of stored rectangles. */
1804 get_glyph_string_clip_rects (s
, rects
, n
)
1805 struct glyph_string
*s
;
1806 NativeRectangle
*rects
;
1814 if (s
->row
->full_width_p
)
1816 /* Draw full-width. X coordinates are relative to S->w->left_col. */
1817 r
.x
= WINDOW_LEFT_EDGE_X (s
->w
);
1818 r
.width
= WINDOW_TOTAL_WIDTH (s
->w
);
1820 /* Unless displaying a mode or menu bar line, which are always
1821 fully visible, clip to the visible part of the row. */
1822 if (s
->w
->pseudo_window_p
)
1823 r
.height
= s
->row
->visible_height
;
1825 r
.height
= s
->height
;
1829 /* This is a text line that may be partially visible. */
1830 r
.x
= window_box_left (s
->w
, s
->area
);
1831 r
.width
= window_box_width (s
->w
, s
->area
);
1832 r
.height
= s
->row
->visible_height
;
1836 if (r
.x
< s
->clip_head
->x
)
1838 if (r
.width
>= s
->clip_head
->x
- r
.x
)
1839 r
.width
-= s
->clip_head
->x
- r
.x
;
1842 r
.x
= s
->clip_head
->x
;
1845 if (r
.x
+ r
.width
> s
->clip_tail
->x
+ s
->clip_tail
->background_width
)
1847 if (s
->clip_tail
->x
+ s
->clip_tail
->background_width
>= r
.x
)
1848 r
.width
= s
->clip_tail
->x
+ s
->clip_tail
->background_width
- r
.x
;
1853 /* If S draws overlapping rows, it's sufficient to use the top and
1854 bottom of the window for clipping because this glyph string
1855 intentionally draws over other lines. */
1856 if (s
->for_overlaps
)
1858 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
1859 r
.height
= window_text_bottom_y (s
->w
) - r
.y
;
1861 /* Alas, the above simple strategy does not work for the
1862 environments with anti-aliased text: if the same text is
1863 drawn onto the same place multiple times, it gets thicker.
1864 If the overlap we are processing is for the erased cursor, we
1865 take the intersection with the rectagle of the cursor. */
1866 if (s
->for_overlaps
& OVERLAPS_ERASED_CURSOR
)
1868 XRectangle rc
, r_save
= r
;
1870 rc
.x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (s
->w
, s
->w
->phys_cursor
.x
);
1871 rc
.y
= s
->w
->phys_cursor
.y
;
1872 rc
.width
= s
->w
->phys_cursor_width
;
1873 rc
.height
= s
->w
->phys_cursor_height
;
1875 x_intersect_rectangles (&r_save
, &rc
, &r
);
1880 /* Don't use S->y for clipping because it doesn't take partially
1881 visible lines into account. For example, it can be negative for
1882 partially visible lines at the top of a window. */
1883 if (!s
->row
->full_width_p
1884 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
1885 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
1887 r
.y
= max (0, s
->row
->y
);
1889 /* If drawing a tool-bar window, draw it over the internal border
1890 at the top of the window. */
1891 if (WINDOWP (s
->f
->tool_bar_window
)
1892 && s
->w
== XWINDOW (s
->f
->tool_bar_window
))
1893 r
.y
-= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
1896 r
.y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
.y
);
1898 /* If drawing the cursor, don't let glyph draw outside its
1899 advertised boundaries. Cleartype does this under some circumstances. */
1900 if (s
->hl
== DRAW_CURSOR
)
1902 struct glyph
*glyph
= s
->first_glyph
;
1907 r
.width
-= s
->x
- r
.x
;
1910 r
.width
= min (r
.width
, glyph
->pixel_width
);
1912 /* If r.y is below window bottom, ensure that we still see a cursor. */
1913 height
= min (glyph
->ascent
+ glyph
->descent
,
1914 min (FRAME_LINE_HEIGHT (s
->f
), s
->row
->visible_height
));
1915 max_y
= window_text_bottom_y (s
->w
) - height
;
1916 max_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, max_y
);
1917 if (s
->ybase
- glyph
->ascent
> max_y
)
1924 /* Don't draw cursor glyph taller than our actual glyph. */
1925 height
= max (FRAME_LINE_HEIGHT (s
->f
), glyph
->ascent
+ glyph
->descent
);
1926 if (height
< r
.height
)
1928 max_y
= r
.y
+ r
.height
;
1929 r
.y
= min (max_y
, max (r
.y
, s
->ybase
+ glyph
->descent
- height
));
1930 r
.height
= min (max_y
- r
.y
, height
);
1937 XRectangle r_save
= r
;
1939 if (! x_intersect_rectangles (&r_save
, s
->row
->clip
, &r
))
1943 if ((s
->for_overlaps
& OVERLAPS_BOTH
) == 0
1944 || ((s
->for_overlaps
& OVERLAPS_BOTH
) == OVERLAPS_BOTH
&& n
== 1))
1946 #ifdef CONVERT_FROM_XRECT
1947 CONVERT_FROM_XRECT (r
, *rects
);
1955 /* If we are processing overlapping and allowed to return
1956 multiple clipping rectangles, we exclude the row of the glyph
1957 string from the clipping rectangle. This is to avoid drawing
1958 the same text on the environment with anti-aliasing. */
1959 #ifdef CONVERT_FROM_XRECT
1962 XRectangle
*rs
= rects
;
1964 int i
= 0, row_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, s
->row
->y
);
1966 if (s
->for_overlaps
& OVERLAPS_PRED
)
1969 if (r
.y
+ r
.height
> row_y
)
1972 rs
[i
].height
= row_y
- r
.y
;
1978 if (s
->for_overlaps
& OVERLAPS_SUCC
)
1981 if (r
.y
< row_y
+ s
->row
->visible_height
)
1983 if (r
.y
+ r
.height
> row_y
+ s
->row
->visible_height
)
1985 rs
[i
].y
= row_y
+ s
->row
->visible_height
;
1986 rs
[i
].height
= r
.y
+ r
.height
- rs
[i
].y
;
1995 #ifdef CONVERT_FROM_XRECT
1996 for (i
= 0; i
< n
; i
++)
1997 CONVERT_FROM_XRECT (rs
[i
], rects
[i
]);
2004 Return in *NR the clipping rectangle for glyph string S. */
2007 get_glyph_string_clip_rect (s
, nr
)
2008 struct glyph_string
*s
;
2009 NativeRectangle
*nr
;
2011 get_glyph_string_clip_rects (s
, nr
, 1);
2016 Return the position and height of the phys cursor in window W.
2017 Set w->phys_cursor_width to width of phys cursor.
2021 get_phys_cursor_geometry (w
, row
, glyph
, xp
, yp
, heightp
)
2023 struct glyph_row
*row
;
2024 struct glyph
*glyph
;
2025 int *xp
, *yp
, *heightp
;
2027 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2028 int x
, y
, wd
, h
, h0
, y0
;
2030 /* Compute the width of the rectangle to draw. If on a stretch
2031 glyph, and `x-stretch-block-cursor' is nil, don't draw a
2032 rectangle as wide as the glyph, but use a canonical character
2034 wd
= glyph
->pixel_width
- 1;
2039 x
= w
->phys_cursor
.x
;
2046 if (glyph
->type
== STRETCH_GLYPH
2047 && !x_stretch_cursor_p
)
2048 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
2049 w
->phys_cursor_width
= wd
;
2051 y
= w
->phys_cursor
.y
+ row
->ascent
- glyph
->ascent
;
2053 /* If y is below window bottom, ensure that we still see a cursor. */
2054 h0
= min (FRAME_LINE_HEIGHT (f
), row
->visible_height
);
2056 h
= max (h0
, glyph
->ascent
+ glyph
->descent
);
2057 h0
= min (h0
, glyph
->ascent
+ glyph
->descent
);
2059 y0
= WINDOW_HEADER_LINE_HEIGHT (w
);
2062 h
= max (h
- (y0
- y
) + 1, h0
);
2067 y0
= window_text_bottom_y (w
) - h0
;
2075 *xp
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, x
);
2076 *yp
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
);
2081 * Remember which glyph the mouse is over.
2085 remember_mouse_glyph (f
, gx
, gy
, rect
)
2088 NativeRectangle
*rect
;
2092 struct glyph_row
*r
, *gr
, *end_row
;
2093 enum window_part part
;
2094 enum glyph_row_area area
;
2095 int x
, y
, width
, height
;
2097 /* Try to determine frame pixel position and size of the glyph under
2098 frame pixel coordinates X/Y on frame F. */
2100 if (!f
->glyphs_initialized_p
2101 || (window
= window_from_coordinates (f
, gx
, gy
, &part
, &x
, &y
, 0),
2104 width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2105 height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2109 w
= XWINDOW (window
);
2110 width
= WINDOW_FRAME_COLUMN_WIDTH (w
);
2111 height
= WINDOW_FRAME_LINE_HEIGHT (w
);
2113 r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
2114 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
2116 if (w
->pseudo_window_p
)
2119 part
= ON_MODE_LINE
; /* Don't adjust margin. */
2125 case ON_LEFT_MARGIN
:
2126 area
= LEFT_MARGIN_AREA
;
2129 case ON_RIGHT_MARGIN
:
2130 area
= RIGHT_MARGIN_AREA
;
2133 case ON_HEADER_LINE
:
2135 gr
= (part
== ON_HEADER_LINE
2136 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
2137 : MATRIX_MODE_LINE_ROW (w
->current_matrix
));
2140 goto text_glyph_row_found
;
2147 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2148 if (r
->y
+ r
->height
> y
)
2154 text_glyph_row_found
:
2157 struct glyph
*g
= gr
->glyphs
[area
];
2158 struct glyph
*end
= g
+ gr
->used
[area
];
2160 height
= gr
->height
;
2161 for (gx
= gr
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
2162 if (gx
+ g
->pixel_width
> x
)
2167 if (g
->type
== IMAGE_GLYPH
)
2169 /* Don't remember when mouse is over image, as
2170 image may have hot-spots. */
2171 STORE_NATIVE_RECT (*rect
, 0, 0, 0, 0);
2174 width
= g
->pixel_width
;
2178 /* Use nominal char spacing at end of line. */
2180 gx
+= (x
/ width
) * width
;
2183 if (part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
)
2184 gx
+= window_box_left_offset (w
, area
);
2188 /* Use nominal line height at end of window. */
2189 gx
= (x
/ width
) * width
;
2191 gy
+= (y
/ height
) * height
;
2195 case ON_LEFT_FRINGE
:
2196 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2197 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
)
2198 : window_box_right_offset (w
, LEFT_MARGIN_AREA
));
2199 width
= WINDOW_LEFT_FRINGE_WIDTH (w
);
2202 case ON_RIGHT_FRINGE
:
2203 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2204 ? window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2205 : window_box_right_offset (w
, TEXT_AREA
));
2206 width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
2210 gx
= (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
2212 : (window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2213 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2214 ? WINDOW_RIGHT_FRINGE_WIDTH (w
)
2216 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
2220 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2221 if (r
->y
+ r
->height
> y
)
2228 height
= gr
->height
;
2231 /* Use nominal line height at end of window. */
2233 gy
+= (y
/ height
) * height
;
2240 /* If there is no glyph under the mouse, then we divide the screen
2241 into a grid of the smallest glyph in the frame, and use that
2244 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
2245 round down even for negative values. */
2251 gx
= (gx
/ width
) * width
;
2252 gy
= (gy
/ height
) * height
;
2257 gx
+= WINDOW_LEFT_EDGE_X (w
);
2258 gy
+= WINDOW_TOP_EDGE_Y (w
);
2261 STORE_NATIVE_RECT (*rect
, gx
, gy
, width
, height
);
2263 /* Visible feedback for debugging. */
2266 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2267 f
->output_data
.x
->normal_gc
,
2268 gx
, gy
, width
, height
);
2274 #endif /* HAVE_WINDOW_SYSTEM */
2277 /***********************************************************************
2278 Lisp form evaluation
2279 ***********************************************************************/
2281 /* Error handler for safe_eval and safe_call. */
2284 safe_eval_handler (arg
)
2287 add_to_log ("Error during redisplay: %s", arg
, Qnil
);
2292 /* Evaluate SEXPR and return the result, or nil if something went
2293 wrong. Prevent redisplay during the evaluation. */
2301 if (inhibit_eval_during_redisplay
)
2305 int count
= SPECPDL_INDEX ();
2306 struct gcpro gcpro1
;
2309 specbind (Qinhibit_redisplay
, Qt
);
2310 /* Use Qt to ensure debugger does not run,
2311 so there is no possibility of wanting to redisplay. */
2312 val
= internal_condition_case_1 (Feval
, sexpr
, Qt
,
2315 val
= unbind_to (count
, val
);
2322 /* Call function ARGS[0] with arguments ARGS[1] to ARGS[NARGS - 1].
2323 Return the result, or nil if something went wrong. Prevent
2324 redisplay during the evaluation. */
2327 safe_call (nargs
, args
)
2333 if (inhibit_eval_during_redisplay
)
2337 int count
= SPECPDL_INDEX ();
2338 struct gcpro gcpro1
;
2341 gcpro1
.nvars
= nargs
;
2342 specbind (Qinhibit_redisplay
, Qt
);
2343 /* Use Qt to ensure debugger does not run,
2344 so there is no possibility of wanting to redisplay. */
2345 val
= internal_condition_case_2 (Ffuncall
, nargs
, args
, Qt
,
2348 val
= unbind_to (count
, val
);
2355 /* Call function FN with one argument ARG.
2356 Return the result, or nil if something went wrong. */
2359 safe_call1 (fn
, arg
)
2360 Lisp_Object fn
, arg
;
2362 Lisp_Object args
[2];
2365 return safe_call (2, args
);
2370 /***********************************************************************
2372 ***********************************************************************/
2376 /* Define CHECK_IT to perform sanity checks on iterators.
2377 This is for debugging. It is too slow to do unconditionally. */
2383 if (it
->method
== GET_FROM_STRING
)
2385 xassert (STRINGP (it
->string
));
2386 xassert (IT_STRING_CHARPOS (*it
) >= 0);
2390 xassert (IT_STRING_CHARPOS (*it
) < 0);
2391 if (it
->method
== GET_FROM_BUFFER
)
2393 /* Check that character and byte positions agree. */
2394 xassert (IT_CHARPOS (*it
) == BYTE_TO_CHAR (IT_BYTEPOS (*it
)));
2399 xassert (it
->current
.dpvec_index
>= 0);
2401 xassert (it
->current
.dpvec_index
< 0);
2404 #define CHECK_IT(IT) check_it ((IT))
2408 #define CHECK_IT(IT) (void) 0
2415 /* Check that the window end of window W is what we expect it
2416 to be---the last row in the current matrix displaying text. */
2419 check_window_end (w
)
2422 if (!MINI_WINDOW_P (w
)
2423 && !NILP (w
->window_end_valid
))
2425 struct glyph_row
*row
;
2426 xassert ((row
= MATRIX_ROW (w
->current_matrix
,
2427 XFASTINT (w
->window_end_vpos
)),
2429 || MATRIX_ROW_DISPLAYS_TEXT_P (row
)
2430 || MATRIX_ROW_VPOS (row
, w
->current_matrix
) == 0));
2434 #define CHECK_WINDOW_END(W) check_window_end ((W))
2436 #else /* not GLYPH_DEBUG */
2438 #define CHECK_WINDOW_END(W) (void) 0
2440 #endif /* not GLYPH_DEBUG */
2444 /***********************************************************************
2445 Iterator initialization
2446 ***********************************************************************/
2448 /* Initialize IT for displaying current_buffer in window W, starting
2449 at character position CHARPOS. CHARPOS < 0 means that no buffer
2450 position is specified which is useful when the iterator is assigned
2451 a position later. BYTEPOS is the byte position corresponding to
2452 CHARPOS. BYTEPOS < 0 means compute it from CHARPOS.
2454 If ROW is not null, calls to produce_glyphs with IT as parameter
2455 will produce glyphs in that row.
2457 BASE_FACE_ID is the id of a base face to use. It must be one of
2458 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
2459 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
2460 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
2462 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
2463 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
2464 will be initialized to use the corresponding mode line glyph row of
2465 the desired matrix of W. */
2468 init_iterator (it
, w
, charpos
, bytepos
, row
, base_face_id
)
2471 int charpos
, bytepos
;
2472 struct glyph_row
*row
;
2473 enum face_id base_face_id
;
2475 int highlight_region_p
;
2477 /* Some precondition checks. */
2478 xassert (w
!= NULL
&& it
!= NULL
);
2479 xassert (charpos
< 0 || (charpos
>= BUF_BEG (current_buffer
)
2482 /* If face attributes have been changed since the last redisplay,
2483 free realized faces now because they depend on face definitions
2484 that might have changed. Don't free faces while there might be
2485 desired matrices pending which reference these faces. */
2486 if (face_change_count
&& !inhibit_free_realized_faces
)
2488 face_change_count
= 0;
2489 free_all_realized_faces (Qnil
);
2492 /* Use one of the mode line rows of W's desired matrix if
2496 if (base_face_id
== MODE_LINE_FACE_ID
2497 || base_face_id
== MODE_LINE_INACTIVE_FACE_ID
)
2498 row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
2499 else if (base_face_id
== HEADER_LINE_FACE_ID
)
2500 row
= MATRIX_HEADER_LINE_ROW (w
->desired_matrix
);
2504 bzero (it
, sizeof *it
);
2505 it
->current
.overlay_string_index
= -1;
2506 it
->current
.dpvec_index
= -1;
2507 it
->base_face_id
= base_face_id
;
2509 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
2511 /* The window in which we iterate over current_buffer: */
2512 XSETWINDOW (it
->window
, w
);
2514 it
->f
= XFRAME (w
->frame
);
2516 /* Extra space between lines (on window systems only). */
2517 if (base_face_id
== DEFAULT_FACE_ID
2518 && FRAME_WINDOW_P (it
->f
))
2520 if (NATNUMP (current_buffer
->extra_line_spacing
))
2521 it
->extra_line_spacing
= XFASTINT (current_buffer
->extra_line_spacing
);
2522 else if (FLOATP (current_buffer
->extra_line_spacing
))
2523 it
->extra_line_spacing
= (XFLOAT_DATA (current_buffer
->extra_line_spacing
)
2524 * FRAME_LINE_HEIGHT (it
->f
));
2525 else if (it
->f
->extra_line_spacing
> 0)
2526 it
->extra_line_spacing
= it
->f
->extra_line_spacing
;
2527 it
->max_extra_line_spacing
= 0;
2530 /* If realized faces have been removed, e.g. because of face
2531 attribute changes of named faces, recompute them. When running
2532 in batch mode, the face cache of the initial frame is null. If
2533 we happen to get called, make a dummy face cache. */
2534 if (FRAME_FACE_CACHE (it
->f
) == NULL
)
2535 init_frame_faces (it
->f
);
2536 if (FRAME_FACE_CACHE (it
->f
)->used
== 0)
2537 recompute_basic_faces (it
->f
);
2539 /* Current value of the `slice', `space-width', and 'height' properties. */
2540 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
2541 it
->space_width
= Qnil
;
2542 it
->font_height
= Qnil
;
2543 it
->override_ascent
= -1;
2545 /* Are control characters displayed as `^C'? */
2546 it
->ctl_arrow_p
= !NILP (current_buffer
->ctl_arrow
);
2548 /* -1 means everything between a CR and the following line end
2549 is invisible. >0 means lines indented more than this value are
2551 it
->selective
= (INTEGERP (current_buffer
->selective_display
)
2552 ? XFASTINT (current_buffer
->selective_display
)
2553 : (!NILP (current_buffer
->selective_display
)
2555 it
->selective_display_ellipsis_p
2556 = !NILP (current_buffer
->selective_display_ellipses
);
2558 /* Display table to use. */
2559 it
->dp
= window_display_table (w
);
2561 /* Are multibyte characters enabled in current_buffer? */
2562 it
->multibyte_p
= !NILP (current_buffer
->enable_multibyte_characters
);
2564 /* Non-zero if we should highlight the region. */
2566 = (!NILP (Vtransient_mark_mode
)
2567 && !NILP (current_buffer
->mark_active
)
2568 && XMARKER (current_buffer
->mark
)->buffer
!= 0);
2570 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
2571 start and end of a visible region in window IT->w. Set both to
2572 -1 to indicate no region. */
2573 if (highlight_region_p
2574 /* Maybe highlight only in selected window. */
2575 && (/* Either show region everywhere. */
2576 highlight_nonselected_windows
2577 /* Or show region in the selected window. */
2578 || w
== XWINDOW (selected_window
)
2579 /* Or show the region if we are in the mini-buffer and W is
2580 the window the mini-buffer refers to. */
2581 || (MINI_WINDOW_P (XWINDOW (selected_window
))
2582 && WINDOWP (minibuf_selected_window
)
2583 && w
== XWINDOW (minibuf_selected_window
))))
2585 int charpos
= marker_position (current_buffer
->mark
);
2586 it
->region_beg_charpos
= min (PT
, charpos
);
2587 it
->region_end_charpos
= max (PT
, charpos
);
2590 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
2592 /* Get the position at which the redisplay_end_trigger hook should
2593 be run, if it is to be run at all. */
2594 if (MARKERP (w
->redisplay_end_trigger
)
2595 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
2596 it
->redisplay_end_trigger_charpos
2597 = marker_position (w
->redisplay_end_trigger
);
2598 else if (INTEGERP (w
->redisplay_end_trigger
))
2599 it
->redisplay_end_trigger_charpos
= XINT (w
->redisplay_end_trigger
);
2601 /* Correct bogus values of tab_width. */
2602 it
->tab_width
= XINT (current_buffer
->tab_width
);
2603 if (it
->tab_width
<= 0 || it
->tab_width
> 1000)
2606 /* Are lines in the display truncated? */
2607 it
->truncate_lines_p
2608 = (base_face_id
!= DEFAULT_FACE_ID
2609 || XINT (it
->w
->hscroll
)
2610 || (truncate_partial_width_windows
2611 && !WINDOW_FULL_WIDTH_P (it
->w
))
2612 || !NILP (current_buffer
->truncate_lines
));
2614 /* Get dimensions of truncation and continuation glyphs. These are
2615 displayed as fringe bitmaps under X, so we don't need them for such
2617 if (!FRAME_WINDOW_P (it
->f
))
2619 if (it
->truncate_lines_p
)
2621 /* We will need the truncation glyph. */
2622 xassert (it
->glyph_row
== NULL
);
2623 produce_special_glyphs (it
, IT_TRUNCATION
);
2624 it
->truncation_pixel_width
= it
->pixel_width
;
2628 /* We will need the continuation glyph. */
2629 xassert (it
->glyph_row
== NULL
);
2630 produce_special_glyphs (it
, IT_CONTINUATION
);
2631 it
->continuation_pixel_width
= it
->pixel_width
;
2634 /* Reset these values to zero because the produce_special_glyphs
2635 above has changed them. */
2636 it
->pixel_width
= it
->ascent
= it
->descent
= 0;
2637 it
->phys_ascent
= it
->phys_descent
= 0;
2640 /* Set this after getting the dimensions of truncation and
2641 continuation glyphs, so that we don't produce glyphs when calling
2642 produce_special_glyphs, above. */
2643 it
->glyph_row
= row
;
2644 it
->area
= TEXT_AREA
;
2646 /* Get the dimensions of the display area. The display area
2647 consists of the visible window area plus a horizontally scrolled
2648 part to the left of the window. All x-values are relative to the
2649 start of this total display area. */
2650 if (base_face_id
!= DEFAULT_FACE_ID
)
2652 /* Mode lines, menu bar in terminal frames. */
2653 it
->first_visible_x
= 0;
2654 it
->last_visible_x
= WINDOW_TOTAL_WIDTH (w
);
2659 = XFASTINT (it
->w
->hscroll
) * FRAME_COLUMN_WIDTH (it
->f
);
2660 it
->last_visible_x
= (it
->first_visible_x
2661 + window_box_width (w
, TEXT_AREA
));
2663 /* If we truncate lines, leave room for the truncator glyph(s) at
2664 the right margin. Otherwise, leave room for the continuation
2665 glyph(s). Truncation and continuation glyphs are not inserted
2666 for window-based redisplay. */
2667 if (!FRAME_WINDOW_P (it
->f
))
2669 if (it
->truncate_lines_p
)
2670 it
->last_visible_x
-= it
->truncation_pixel_width
;
2672 it
->last_visible_x
-= it
->continuation_pixel_width
;
2675 it
->header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
2676 it
->current_y
= WINDOW_HEADER_LINE_HEIGHT (w
) + w
->vscroll
;
2679 /* Leave room for a border glyph. */
2680 if (!FRAME_WINDOW_P (it
->f
)
2681 && !WINDOW_RIGHTMOST_P (it
->w
))
2682 it
->last_visible_x
-= 1;
2684 it
->last_visible_y
= window_text_bottom_y (w
);
2686 /* For mode lines and alike, arrange for the first glyph having a
2687 left box line if the face specifies a box. */
2688 if (base_face_id
!= DEFAULT_FACE_ID
)
2692 it
->face_id
= base_face_id
;
2694 /* If we have a boxed mode line, make the first character appear
2695 with a left box line. */
2696 face
= FACE_FROM_ID (it
->f
, base_face_id
);
2697 if (face
->box
!= FACE_NO_BOX
)
2698 it
->start_of_box_run_p
= 1;
2701 /* If a buffer position was specified, set the iterator there,
2702 getting overlays and face properties from that position. */
2703 if (charpos
>= BUF_BEG (current_buffer
))
2705 it
->end_charpos
= ZV
;
2707 IT_CHARPOS (*it
) = charpos
;
2709 /* Compute byte position if not specified. */
2710 if (bytepos
< charpos
)
2711 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (charpos
);
2713 IT_BYTEPOS (*it
) = bytepos
;
2715 it
->start
= it
->current
;
2717 /* Compute faces etc. */
2718 reseat (it
, it
->current
.pos
, 1);
2725 /* Initialize IT for the display of window W with window start POS. */
2728 start_display (it
, w
, pos
)
2731 struct text_pos pos
;
2733 struct glyph_row
*row
;
2734 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
2736 row
= w
->desired_matrix
->rows
+ first_vpos
;
2737 init_iterator (it
, w
, CHARPOS (pos
), BYTEPOS (pos
), row
, DEFAULT_FACE_ID
);
2738 it
->first_vpos
= first_vpos
;
2740 /* Don't reseat to previous visible line start if current start
2741 position is in a string or image. */
2742 if (it
->method
== GET_FROM_BUFFER
&& !it
->truncate_lines_p
)
2744 int start_at_line_beg_p
;
2745 int first_y
= it
->current_y
;
2747 /* If window start is not at a line start, skip forward to POS to
2748 get the correct continuation lines width. */
2749 start_at_line_beg_p
= (CHARPOS (pos
) == BEGV
2750 || FETCH_BYTE (BYTEPOS (pos
) - 1) == '\n');
2751 if (!start_at_line_beg_p
)
2755 reseat_at_previous_visible_line_start (it
);
2756 move_it_to (it
, CHARPOS (pos
), -1, -1, -1, MOVE_TO_POS
);
2758 new_x
= it
->current_x
+ it
->pixel_width
;
2760 /* If lines are continued, this line may end in the middle
2761 of a multi-glyph character (e.g. a control character
2762 displayed as \003, or in the middle of an overlay
2763 string). In this case move_it_to above will not have
2764 taken us to the start of the continuation line but to the
2765 end of the continued line. */
2766 if (it
->current_x
> 0
2767 && !it
->truncate_lines_p
/* Lines are continued. */
2768 && (/* And glyph doesn't fit on the line. */
2769 new_x
> it
->last_visible_x
2770 /* Or it fits exactly and we're on a window
2772 || (new_x
== it
->last_visible_x
2773 && FRAME_WINDOW_P (it
->f
))))
2775 if (it
->current
.dpvec_index
>= 0
2776 || it
->current
.overlay_string_index
>= 0)
2778 set_iterator_to_next (it
, 1);
2779 move_it_in_display_line_to (it
, -1, -1, 0);
2782 it
->continuation_lines_width
+= it
->current_x
;
2785 /* We're starting a new display line, not affected by the
2786 height of the continued line, so clear the appropriate
2787 fields in the iterator structure. */
2788 it
->max_ascent
= it
->max_descent
= 0;
2789 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
2791 it
->current_y
= first_y
;
2793 it
->current_x
= it
->hpos
= 0;
2797 #if 0 /* Don't assert the following because start_display is sometimes
2798 called intentionally with a window start that is not at a
2799 line start. Please leave this code in as a comment. */
2801 /* Window start should be on a line start, now. */
2802 xassert (it
->continuation_lines_width
2803 || IT_CHARPOS (it
) == BEGV
2804 || FETCH_BYTE (IT_BYTEPOS (it
) - 1) == '\n');
2809 /* Return 1 if POS is a position in ellipses displayed for invisible
2810 text. W is the window we display, for text property lookup. */
2813 in_ellipses_for_invisible_text_p (pos
, w
)
2814 struct display_pos
*pos
;
2817 Lisp_Object prop
, window
;
2819 int charpos
= CHARPOS (pos
->pos
);
2821 /* If POS specifies a position in a display vector, this might
2822 be for an ellipsis displayed for invisible text. We won't
2823 get the iterator set up for delivering that ellipsis unless
2824 we make sure that it gets aware of the invisible text. */
2825 if (pos
->dpvec_index
>= 0
2826 && pos
->overlay_string_index
< 0
2827 && CHARPOS (pos
->string_pos
) < 0
2829 && (XSETWINDOW (window
, w
),
2830 prop
= Fget_char_property (make_number (charpos
),
2831 Qinvisible
, window
),
2832 !TEXT_PROP_MEANS_INVISIBLE (prop
)))
2834 prop
= Fget_char_property (make_number (charpos
- 1), Qinvisible
,
2836 ellipses_p
= 2 == TEXT_PROP_MEANS_INVISIBLE (prop
);
2843 /* Initialize IT for stepping through current_buffer in window W,
2844 starting at position POS that includes overlay string and display
2845 vector/ control character translation position information. Value
2846 is zero if there are overlay strings with newlines at POS. */
2849 init_from_display_pos (it
, w
, pos
)
2852 struct display_pos
*pos
;
2854 int charpos
= CHARPOS (pos
->pos
), bytepos
= BYTEPOS (pos
->pos
);
2855 int i
, overlay_strings_with_newlines
= 0;
2857 /* If POS specifies a position in a display vector, this might
2858 be for an ellipsis displayed for invisible text. We won't
2859 get the iterator set up for delivering that ellipsis unless
2860 we make sure that it gets aware of the invisible text. */
2861 if (in_ellipses_for_invisible_text_p (pos
, w
))
2867 /* Keep in mind: the call to reseat in init_iterator skips invisible
2868 text, so we might end up at a position different from POS. This
2869 is only a problem when POS is a row start after a newline and an
2870 overlay starts there with an after-string, and the overlay has an
2871 invisible property. Since we don't skip invisible text in
2872 display_line and elsewhere immediately after consuming the
2873 newline before the row start, such a POS will not be in a string,
2874 but the call to init_iterator below will move us to the
2876 init_iterator (it
, w
, charpos
, bytepos
, NULL
, DEFAULT_FACE_ID
);
2878 /* This only scans the current chunk -- it should scan all chunks.
2879 However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
2880 to 16 in 22.1 to make this a lesser problem. */
2881 for (i
= 0; i
< it
->n_overlay_strings
&& i
< OVERLAY_STRING_CHUNK_SIZE
; ++i
)
2883 const char *s
= SDATA (it
->overlay_strings
[i
]);
2884 const char *e
= s
+ SBYTES (it
->overlay_strings
[i
]);
2886 while (s
< e
&& *s
!= '\n')
2891 overlay_strings_with_newlines
= 1;
2896 /* If position is within an overlay string, set up IT to the right
2898 if (pos
->overlay_string_index
>= 0)
2902 /* If the first overlay string happens to have a `display'
2903 property for an image, the iterator will be set up for that
2904 image, and we have to undo that setup first before we can
2905 correct the overlay string index. */
2906 if (it
->method
== GET_FROM_IMAGE
)
2909 /* We already have the first chunk of overlay strings in
2910 IT->overlay_strings. Load more until the one for
2911 pos->overlay_string_index is in IT->overlay_strings. */
2912 if (pos
->overlay_string_index
>= OVERLAY_STRING_CHUNK_SIZE
)
2914 int n
= pos
->overlay_string_index
/ OVERLAY_STRING_CHUNK_SIZE
;
2915 it
->current
.overlay_string_index
= 0;
2918 load_overlay_strings (it
, 0);
2919 it
->current
.overlay_string_index
+= OVERLAY_STRING_CHUNK_SIZE
;
2923 it
->current
.overlay_string_index
= pos
->overlay_string_index
;
2924 relative_index
= (it
->current
.overlay_string_index
2925 % OVERLAY_STRING_CHUNK_SIZE
);
2926 it
->string
= it
->overlay_strings
[relative_index
];
2927 xassert (STRINGP (it
->string
));
2928 it
->current
.string_pos
= pos
->string_pos
;
2929 it
->method
= GET_FROM_STRING
;
2932 #if 0 /* This is bogus because POS not having an overlay string
2933 position does not mean it's after the string. Example: A
2934 line starting with a before-string and initialization of IT
2935 to the previous row's end position. */
2936 else if (it
->current
.overlay_string_index
>= 0)
2938 /* If POS says we're already after an overlay string ending at
2939 POS, make sure to pop the iterator because it will be in
2940 front of that overlay string. When POS is ZV, we've thereby
2941 also ``processed'' overlay strings at ZV. */
2944 xassert (it
->current
.overlay_string_index
== -1);
2945 xassert (it
->method
== GET_FROM_BUFFER
);
2946 if (CHARPOS (pos
->pos
) == ZV
)
2947 it
->overlay_strings_at_end_processed_p
= 1;
2951 if (CHARPOS (pos
->string_pos
) >= 0)
2953 /* Recorded position is not in an overlay string, but in another
2954 string. This can only be a string from a `display' property.
2955 IT should already be filled with that string. */
2956 it
->current
.string_pos
= pos
->string_pos
;
2957 xassert (STRINGP (it
->string
));
2960 /* Restore position in display vector translations, control
2961 character translations or ellipses. */
2962 if (pos
->dpvec_index
>= 0)
2964 if (it
->dpvec
== NULL
)
2965 get_next_display_element (it
);
2966 xassert (it
->dpvec
&& it
->current
.dpvec_index
== 0);
2967 it
->current
.dpvec_index
= pos
->dpvec_index
;
2971 return !overlay_strings_with_newlines
;
2975 /* Initialize IT for stepping through current_buffer in window W
2976 starting at ROW->start. */
2979 init_to_row_start (it
, w
, row
)
2982 struct glyph_row
*row
;
2984 init_from_display_pos (it
, w
, &row
->start
);
2985 it
->start
= row
->start
;
2986 it
->continuation_lines_width
= row
->continuation_lines_width
;
2991 /* Initialize IT for stepping through current_buffer in window W
2992 starting in the line following ROW, i.e. starting at ROW->end.
2993 Value is zero if there are overlay strings with newlines at ROW's
2997 init_to_row_end (it
, w
, row
)
3000 struct glyph_row
*row
;
3004 if (init_from_display_pos (it
, w
, &row
->end
))
3006 if (row
->continued_p
)
3007 it
->continuation_lines_width
3008 = row
->continuation_lines_width
+ row
->pixel_width
;
3019 /***********************************************************************
3021 ***********************************************************************/
3023 /* Called when IT reaches IT->stop_charpos. Handle text property and
3024 overlay changes. Set IT->stop_charpos to the next position where
3031 enum prop_handled handled
;
3032 int handle_overlay_change_p
;
3036 it
->current
.dpvec_index
= -1;
3037 handle_overlay_change_p
= !it
->ignore_overlay_strings_at_pos_p
;
3038 it
->ignore_overlay_strings_at_pos_p
= 0;
3040 /* Use face of preceding text for ellipsis (if invisible) */
3041 if (it
->selective_display_ellipsis_p
)
3042 it
->saved_face_id
= it
->face_id
;
3046 handled
= HANDLED_NORMALLY
;
3048 /* Call text property handlers. */
3049 for (p
= it_props
; p
->handler
; ++p
)
3051 handled
= p
->handler (it
);
3053 if (handled
== HANDLED_RECOMPUTE_PROPS
)
3055 else if (handled
== HANDLED_RETURN
)
3057 /* We still want to show before and after strings from
3058 overlays even if the actual buffer text is replaced. */
3059 if (!handle_overlay_change_p
|| it
->sp
> 1)
3061 if (!get_overlay_strings_1 (it
, 0, 0))
3063 it
->ignore_overlay_strings_at_pos_p
= 1;
3064 it
->string_from_display_prop_p
= 0;
3065 handle_overlay_change_p
= 0;
3066 handled
= HANDLED_RECOMPUTE_PROPS
;
3069 else if (handled
== HANDLED_OVERLAY_STRING_CONSUMED
)
3070 handle_overlay_change_p
= 0;
3073 if (handled
!= HANDLED_RECOMPUTE_PROPS
)
3075 /* Don't check for overlay strings below when set to deliver
3076 characters from a display vector. */
3077 if (it
->method
== GET_FROM_DISPLAY_VECTOR
)
3078 handle_overlay_change_p
= 0;
3080 /* Handle overlay changes.
3081 This sets HANDLED to HANDLED_RECOMPUTE_PROPS
3082 if it finds overlays. */
3083 if (handle_overlay_change_p
)
3084 handled
= handle_overlay_change (it
);
3087 while (handled
== HANDLED_RECOMPUTE_PROPS
);
3089 /* Determine where to stop next. */
3090 if (handled
== HANDLED_NORMALLY
)
3091 compute_stop_pos (it
);
3095 /* Compute IT->stop_charpos from text property and overlay change
3096 information for IT's current position. */
3099 compute_stop_pos (it
)
3102 register INTERVAL iv
, next_iv
;
3103 Lisp_Object object
, limit
, position
;
3105 /* If nowhere else, stop at the end. */
3106 it
->stop_charpos
= it
->end_charpos
;
3108 if (STRINGP (it
->string
))
3110 /* Strings are usually short, so don't limit the search for
3112 object
= it
->string
;
3114 position
= make_number (IT_STRING_CHARPOS (*it
));
3120 /* If next overlay change is in front of the current stop pos
3121 (which is IT->end_charpos), stop there. Note: value of
3122 next_overlay_change is point-max if no overlay change
3124 charpos
= next_overlay_change (IT_CHARPOS (*it
));
3125 if (charpos
< it
->stop_charpos
)
3126 it
->stop_charpos
= charpos
;
3128 /* If showing the region, we have to stop at the region
3129 start or end because the face might change there. */
3130 if (it
->region_beg_charpos
> 0)
3132 if (IT_CHARPOS (*it
) < it
->region_beg_charpos
)
3133 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_beg_charpos
);
3134 else if (IT_CHARPOS (*it
) < it
->region_end_charpos
)
3135 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_end_charpos
);
3138 /* Set up variables for computing the stop position from text
3139 property changes. */
3140 XSETBUFFER (object
, current_buffer
);
3141 limit
= make_number (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
);
3142 position
= make_number (IT_CHARPOS (*it
));
3146 /* Get the interval containing IT's position. Value is a null
3147 interval if there isn't such an interval. */
3148 iv
= validate_interval_range (object
, &position
, &position
, 0);
3149 if (!NULL_INTERVAL_P (iv
))
3151 Lisp_Object values_here
[LAST_PROP_IDX
];
3154 /* Get properties here. */
3155 for (p
= it_props
; p
->handler
; ++p
)
3156 values_here
[p
->idx
] = textget (iv
->plist
, *p
->name
);
3158 /* Look for an interval following iv that has different
3160 for (next_iv
= next_interval (iv
);
3161 (!NULL_INTERVAL_P (next_iv
)
3163 || XFASTINT (limit
) > next_iv
->position
));
3164 next_iv
= next_interval (next_iv
))
3166 for (p
= it_props
; p
->handler
; ++p
)
3168 Lisp_Object new_value
;
3170 new_value
= textget (next_iv
->plist
, *p
->name
);
3171 if (!EQ (values_here
[p
->idx
], new_value
))
3179 if (!NULL_INTERVAL_P (next_iv
))
3181 if (INTEGERP (limit
)
3182 && next_iv
->position
>= XFASTINT (limit
))
3183 /* No text property change up to limit. */
3184 it
->stop_charpos
= min (XFASTINT (limit
), it
->stop_charpos
);
3186 /* Text properties change in next_iv. */
3187 it
->stop_charpos
= min (it
->stop_charpos
, next_iv
->position
);
3191 xassert (STRINGP (it
->string
)
3192 || (it
->stop_charpos
>= BEGV
3193 && it
->stop_charpos
>= IT_CHARPOS (*it
)));
3197 /* Return the position of the next overlay change after POS in
3198 current_buffer. Value is point-max if no overlay change
3199 follows. This is like `next-overlay-change' but doesn't use
3203 next_overlay_change (pos
)
3208 Lisp_Object
*overlays
;
3211 /* Get all overlays at the given position. */
3212 GET_OVERLAYS_AT (pos
, overlays
, noverlays
, &endpos
, 1);
3214 /* If any of these overlays ends before endpos,
3215 use its ending point instead. */
3216 for (i
= 0; i
< noverlays
; ++i
)
3221 oend
= OVERLAY_END (overlays
[i
]);
3222 oendpos
= OVERLAY_POSITION (oend
);
3223 endpos
= min (endpos
, oendpos
);
3231 /***********************************************************************
3233 ***********************************************************************/
3235 /* Handle changes in the `fontified' property of the current buffer by
3236 calling hook functions from Qfontification_functions to fontify
3239 static enum prop_handled
3240 handle_fontified_prop (it
)
3243 Lisp_Object prop
, pos
;
3244 enum prop_handled handled
= HANDLED_NORMALLY
;
3246 if (!NILP (Vmemory_full
))
3249 /* Get the value of the `fontified' property at IT's current buffer
3250 position. (The `fontified' property doesn't have a special
3251 meaning in strings.) If the value is nil, call functions from
3252 Qfontification_functions. */
3253 if (!STRINGP (it
->string
)
3255 && !NILP (Vfontification_functions
)
3256 && !NILP (Vrun_hooks
)
3257 && (pos
= make_number (IT_CHARPOS (*it
)),
3258 prop
= Fget_char_property (pos
, Qfontified
, Qnil
),
3259 /* Ignore the special cased nil value always present at EOB since
3260 no amount of fontifying will be able to change it. */
3261 NILP (prop
) && IT_CHARPOS (*it
) < Z
))
3263 int count
= SPECPDL_INDEX ();
3266 val
= Vfontification_functions
;
3267 specbind (Qfontification_functions
, Qnil
);
3269 if (!CONSP (val
) || EQ (XCAR (val
), Qlambda
))
3270 safe_call1 (val
, pos
);
3273 Lisp_Object globals
, fn
;
3274 struct gcpro gcpro1
, gcpro2
;
3277 GCPRO2 (val
, globals
);
3279 for (; CONSP (val
); val
= XCDR (val
))
3285 /* A value of t indicates this hook has a local
3286 binding; it means to run the global binding too.
3287 In a global value, t should not occur. If it
3288 does, we must ignore it to avoid an endless
3290 for (globals
= Fdefault_value (Qfontification_functions
);
3292 globals
= XCDR (globals
))
3294 fn
= XCAR (globals
);
3296 safe_call1 (fn
, pos
);
3300 safe_call1 (fn
, pos
);
3306 unbind_to (count
, Qnil
);
3308 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
3309 something. This avoids an endless loop if they failed to
3310 fontify the text for which reason ever. */
3311 if (!NILP (Fget_char_property (pos
, Qfontified
, Qnil
)))
3312 handled
= HANDLED_RECOMPUTE_PROPS
;
3320 /***********************************************************************
3322 ***********************************************************************/
3324 /* Set up iterator IT from face properties at its current position.
3325 Called from handle_stop. */
3327 static enum prop_handled
3328 handle_face_prop (it
)
3331 int new_face_id
, next_stop
;
3333 if (!STRINGP (it
->string
))
3336 = face_at_buffer_position (it
->w
,
3338 it
->region_beg_charpos
,
3339 it
->region_end_charpos
,
3342 + TEXT_PROP_DISTANCE_LIMIT
),
3345 /* Is this a start of a run of characters with box face?
3346 Caveat: this can be called for a freshly initialized
3347 iterator; face_id is -1 in this case. We know that the new
3348 face will not change until limit, i.e. if the new face has a
3349 box, all characters up to limit will have one. But, as
3350 usual, we don't know whether limit is really the end. */
3351 if (new_face_id
!= it
->face_id
)
3353 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3355 /* If new face has a box but old face has not, this is
3356 the start of a run of characters with box, i.e. it has
3357 a shadow on the left side. The value of face_id of the
3358 iterator will be -1 if this is the initial call that gets
3359 the face. In this case, we have to look in front of IT's
3360 position and see whether there is a face != new_face_id. */
3361 it
->start_of_box_run_p
3362 = (new_face
->box
!= FACE_NO_BOX
3363 && (it
->face_id
>= 0
3364 || IT_CHARPOS (*it
) == BEG
3365 || new_face_id
!= face_before_it_pos (it
)));
3366 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3371 int base_face_id
, bufpos
;
3373 Lisp_Object from_overlay
3374 = (it
->current
.overlay_string_index
>= 0
3375 ? it
->string_overlays
[it
->current
.overlay_string_index
]
3378 /* See if we got to this string directly or indirectly from
3379 an overlay property. That includes the before-string or
3380 after-string of an overlay, strings in display properties
3381 provided by an overlay, their text properties, etc.
3383 FROM_OVERLAY is the overlay that brought us here, or nil if none. */
3384 if (! NILP (from_overlay
))
3385 for (i
= it
->sp
- 1; i
>= 0; i
--)
3387 if (it
->stack
[i
].current
.overlay_string_index
>= 0)
3389 = it
->string_overlays
[it
->stack
[i
].current
.overlay_string_index
];
3390 else if (! NILP (it
->stack
[i
].from_overlay
))
3391 from_overlay
= it
->stack
[i
].from_overlay
;
3393 if (!NILP (from_overlay
))
3397 if (! NILP (from_overlay
))
3399 bufpos
= IT_CHARPOS (*it
);
3400 /* For a string from an overlay, the base face depends
3401 only on text properties and ignores overlays. */
3403 = face_for_overlay_string (it
->w
,
3405 it
->region_beg_charpos
,
3406 it
->region_end_charpos
,
3409 + TEXT_PROP_DISTANCE_LIMIT
),
3417 /* For strings from a `display' property, use the face at
3418 IT's current buffer position as the base face to merge
3419 with, so that overlay strings appear in the same face as
3420 surrounding text, unless they specify their own
3422 base_face_id
= underlying_face_id (it
);
3425 new_face_id
= face_at_string_position (it
->w
,
3427 IT_STRING_CHARPOS (*it
),
3429 it
->region_beg_charpos
,
3430 it
->region_end_charpos
,
3434 #if 0 /* This shouldn't be neccessary. Let's check it. */
3435 /* If IT is used to display a mode line we would really like to
3436 use the mode line face instead of the frame's default face. */
3437 if (it
->glyph_row
== MATRIX_MODE_LINE_ROW (it
->w
->desired_matrix
)
3438 && new_face_id
== DEFAULT_FACE_ID
)
3439 new_face_id
= CURRENT_MODE_LINE_FACE_ID (it
->w
);
3442 /* Is this a start of a run of characters with box? Caveat:
3443 this can be called for a freshly allocated iterator; face_id
3444 is -1 is this case. We know that the new face will not
3445 change until the next check pos, i.e. if the new face has a
3446 box, all characters up to that position will have a
3447 box. But, as usual, we don't know whether that position
3448 is really the end. */
3449 if (new_face_id
!= it
->face_id
)
3451 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3452 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
3454 /* If new face has a box but old face hasn't, this is the
3455 start of a run of characters with box, i.e. it has a
3456 shadow on the left side. */
3457 it
->start_of_box_run_p
3458 = new_face
->box
&& (old_face
== NULL
|| !old_face
->box
);
3459 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3463 it
->face_id
= new_face_id
;
3464 return HANDLED_NORMALLY
;
3468 /* Return the ID of the face ``underlying'' IT's current position,
3469 which is in a string. If the iterator is associated with a
3470 buffer, return the face at IT's current buffer position.
3471 Otherwise, use the iterator's base_face_id. */
3474 underlying_face_id (it
)
3477 int face_id
= it
->base_face_id
, i
;
3479 xassert (STRINGP (it
->string
));
3481 for (i
= it
->sp
- 1; i
>= 0; --i
)
3482 if (NILP (it
->stack
[i
].string
))
3483 face_id
= it
->stack
[i
].face_id
;
3489 /* Compute the face one character before or after the current position
3490 of IT. BEFORE_P non-zero means get the face in front of IT's
3491 position. Value is the id of the face. */
3494 face_before_or_after_it_pos (it
, before_p
)
3499 int next_check_charpos
;
3500 struct text_pos pos
;
3502 xassert (it
->s
== NULL
);
3504 if (STRINGP (it
->string
))
3506 int bufpos
, base_face_id
;
3508 /* No face change past the end of the string (for the case
3509 we are padding with spaces). No face change before the
3511 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
)
3512 || (IT_STRING_CHARPOS (*it
) == 0 && before_p
))
3515 /* Set pos to the position before or after IT's current position. */
3517 pos
= string_pos (IT_STRING_CHARPOS (*it
) - 1, it
->string
);
3519 /* For composition, we must check the character after the
3521 pos
= (it
->what
== IT_COMPOSITION
3522 ? string_pos (IT_STRING_CHARPOS (*it
) + it
->cmp_len
, it
->string
)
3523 : string_pos (IT_STRING_CHARPOS (*it
) + 1, it
->string
));
3525 if (it
->current
.overlay_string_index
>= 0)
3526 bufpos
= IT_CHARPOS (*it
);
3530 base_face_id
= underlying_face_id (it
);
3532 /* Get the face for ASCII, or unibyte. */
3533 face_id
= face_at_string_position (it
->w
,
3537 it
->region_beg_charpos
,
3538 it
->region_end_charpos
,
3539 &next_check_charpos
,
3542 /* Correct the face for charsets different from ASCII. Do it
3543 for the multibyte case only. The face returned above is
3544 suitable for unibyte text if IT->string is unibyte. */
3545 if (STRING_MULTIBYTE (it
->string
))
3547 const unsigned char *p
= SDATA (it
->string
) + BYTEPOS (pos
);
3548 int rest
= SBYTES (it
->string
) - BYTEPOS (pos
);
3550 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
3552 c
= string_char_and_length (p
, rest
, &len
);
3553 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, CHARPOS (pos
), it
->string
);
3558 if ((IT_CHARPOS (*it
) >= ZV
&& !before_p
)
3559 || (IT_CHARPOS (*it
) <= BEGV
&& before_p
))
3562 limit
= IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
;
3563 pos
= it
->current
.pos
;
3566 DEC_TEXT_POS (pos
, it
->multibyte_p
);
3569 if (it
->what
== IT_COMPOSITION
)
3570 /* For composition, we must check the position after the
3572 pos
.charpos
+= it
->cmp_len
, pos
.bytepos
+= it
->len
;
3574 INC_TEXT_POS (pos
, it
->multibyte_p
);
3577 /* Determine face for CHARSET_ASCII, or unibyte. */
3578 face_id
= face_at_buffer_position (it
->w
,
3580 it
->region_beg_charpos
,
3581 it
->region_end_charpos
,
3582 &next_check_charpos
,
3585 /* Correct the face for charsets different from ASCII. Do it
3586 for the multibyte case only. The face returned above is
3587 suitable for unibyte text if current_buffer is unibyte. */
3588 if (it
->multibyte_p
)
3590 int c
= FETCH_MULTIBYTE_CHAR (BYTEPOS (pos
));
3591 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
3592 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, CHARPOS (pos
), Qnil
);
3601 /***********************************************************************
3603 ***********************************************************************/
3605 /* Set up iterator IT from invisible properties at its current
3606 position. Called from handle_stop. */
3608 static enum prop_handled
3609 handle_invisible_prop (it
)
3612 enum prop_handled handled
= HANDLED_NORMALLY
;
3614 if (STRINGP (it
->string
))
3616 extern Lisp_Object Qinvisible
;
3617 Lisp_Object prop
, end_charpos
, limit
, charpos
;
3619 /* Get the value of the invisible text property at the
3620 current position. Value will be nil if there is no such
3622 charpos
= make_number (IT_STRING_CHARPOS (*it
));
3623 prop
= Fget_text_property (charpos
, Qinvisible
, it
->string
);
3626 && IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
3628 handled
= HANDLED_RECOMPUTE_PROPS
;
3630 /* Get the position at which the next change of the
3631 invisible text property can be found in IT->string.
3632 Value will be nil if the property value is the same for
3633 all the rest of IT->string. */
3634 XSETINT (limit
, SCHARS (it
->string
));
3635 end_charpos
= Fnext_single_property_change (charpos
, Qinvisible
,
3638 /* Text at current position is invisible. The next
3639 change in the property is at position end_charpos.
3640 Move IT's current position to that position. */
3641 if (INTEGERP (end_charpos
)
3642 && XFASTINT (end_charpos
) < XFASTINT (limit
))
3644 struct text_pos old
;
3645 old
= it
->current
.string_pos
;
3646 IT_STRING_CHARPOS (*it
) = XFASTINT (end_charpos
);
3647 compute_string_pos (&it
->current
.string_pos
, old
, it
->string
);
3651 /* The rest of the string is invisible. If this is an
3652 overlay string, proceed with the next overlay string
3653 or whatever comes and return a character from there. */
3654 if (it
->current
.overlay_string_index
>= 0)
3656 next_overlay_string (it
);
3657 /* Don't check for overlay strings when we just
3658 finished processing them. */
3659 handled
= HANDLED_OVERLAY_STRING_CONSUMED
;
3663 IT_STRING_CHARPOS (*it
) = SCHARS (it
->string
);
3664 IT_STRING_BYTEPOS (*it
) = SBYTES (it
->string
);
3672 EMACS_INT newpos
, next_stop
, start_charpos
;
3673 Lisp_Object pos
, prop
, overlay
;
3675 /* First of all, is there invisible text at this position? */
3676 start_charpos
= IT_CHARPOS (*it
);
3677 pos
= make_number (IT_CHARPOS (*it
));
3678 prop
= get_char_property_and_overlay (pos
, Qinvisible
, it
->window
,
3680 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
3682 /* If we are on invisible text, skip over it. */
3683 if (invis_p
&& IT_CHARPOS (*it
) < it
->end_charpos
)
3685 /* Record whether we have to display an ellipsis for the
3687 int display_ellipsis_p
= invis_p
== 2;
3689 handled
= HANDLED_RECOMPUTE_PROPS
;
3691 /* Loop skipping over invisible text. The loop is left at
3692 ZV or with IT on the first char being visible again. */
3695 /* Try to skip some invisible text. Return value is the
3696 position reached which can be equal to IT's position
3697 if there is nothing invisible here. This skips both
3698 over invisible text properties and overlays with
3699 invisible property. */
3700 newpos
= skip_invisible (IT_CHARPOS (*it
),
3701 &next_stop
, ZV
, it
->window
);
3703 /* If we skipped nothing at all we weren't at invisible
3704 text in the first place. If everything to the end of
3705 the buffer was skipped, end the loop. */
3706 if (newpos
== IT_CHARPOS (*it
) || newpos
>= ZV
)
3710 /* We skipped some characters but not necessarily
3711 all there are. Check if we ended up on visible
3712 text. Fget_char_property returns the property of
3713 the char before the given position, i.e. if we
3714 get invis_p = 0, this means that the char at
3715 newpos is visible. */
3716 pos
= make_number (newpos
);
3717 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
3718 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
3721 /* If we ended up on invisible text, proceed to
3722 skip starting with next_stop. */
3724 IT_CHARPOS (*it
) = next_stop
;
3726 /* If there are adjacent invisible texts, don't lose the
3727 second one's ellipsis. */
3729 display_ellipsis_p
= 1;
3733 /* The position newpos is now either ZV or on visible text. */
3734 IT_CHARPOS (*it
) = newpos
;
3735 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (newpos
);
3737 /* If there are before-strings at the start of invisible
3738 text, and the text is invisible because of a text
3739 property, arrange to show before-strings because 20.x did
3740 it that way. (If the text is invisible because of an
3741 overlay property instead of a text property, this is
3742 already handled in the overlay code.) */
3744 && get_overlay_strings (it
, start_charpos
))
3746 handled
= HANDLED_RECOMPUTE_PROPS
;
3747 it
->stack
[it
->sp
- 1].display_ellipsis_p
= display_ellipsis_p
;
3749 else if (display_ellipsis_p
)
3751 /* Make sure that the glyphs of the ellipsis will get
3752 correct `charpos' values. If we would not update
3753 it->position here, the glyphs would belong to the
3754 last visible character _before_ the invisible
3755 text, which confuses `set_cursor_from_row'.
3757 We use the last invisible position instead of the
3758 first because this way the cursor is always drawn on
3759 the first "." of the ellipsis, whenever PT is inside
3760 the invisible text. Otherwise the cursor would be
3761 placed _after_ the ellipsis when the point is after the
3762 first invisible character. */
3763 if (!STRINGP (it
->object
))
3765 it
->position
.charpos
= IT_CHARPOS (*it
) - 1;
3766 it
->position
.bytepos
= CHAR_TO_BYTE (it
->position
.charpos
);
3768 setup_for_ellipsis (it
, 0);
3769 /* Let the ellipsis display before
3770 considering any properties of the following char.
3771 Fixes jasonr@gnu.org 01 Oct 07 bug. */
3772 handled
= HANDLED_RETURN
;
3781 /* Make iterator IT return `...' next.
3782 Replaces LEN characters from buffer. */
3785 setup_for_ellipsis (it
, len
)
3789 /* Use the display table definition for `...'. Invalid glyphs
3790 will be handled by the method returning elements from dpvec. */
3791 if (it
->dp
&& VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
3793 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
3794 it
->dpvec
= v
->contents
;
3795 it
->dpend
= v
->contents
+ v
->size
;
3799 /* Default `...'. */
3800 it
->dpvec
= default_invis_vector
;
3801 it
->dpend
= default_invis_vector
+ 3;
3804 it
->dpvec_char_len
= len
;
3805 it
->current
.dpvec_index
= 0;
3806 it
->dpvec_face_id
= -1;
3808 /* Remember the current face id in case glyphs specify faces.
3809 IT's face is restored in set_iterator_to_next.
3810 saved_face_id was set to preceding char's face in handle_stop. */
3811 if (it
->saved_face_id
< 0 || it
->saved_face_id
!= it
->face_id
)
3812 it
->saved_face_id
= it
->face_id
= DEFAULT_FACE_ID
;
3814 it
->method
= GET_FROM_DISPLAY_VECTOR
;
3820 /***********************************************************************
3822 ***********************************************************************/
3824 /* Set up iterator IT from `display' property at its current position.
3825 Called from handle_stop.
3826 We return HANDLED_RETURN if some part of the display property
3827 overrides the display of the buffer text itself.
3828 Otherwise we return HANDLED_NORMALLY. */
3830 static enum prop_handled
3831 handle_display_prop (it
)
3834 Lisp_Object prop
, object
, overlay
;
3835 struct text_pos
*position
;
3836 /* Nonzero if some property replaces the display of the text itself. */
3837 int display_replaced_p
= 0;
3839 if (STRINGP (it
->string
))
3841 object
= it
->string
;
3842 position
= &it
->current
.string_pos
;
3846 XSETWINDOW (object
, it
->w
);
3847 position
= &it
->current
.pos
;
3850 /* Reset those iterator values set from display property values. */
3851 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
3852 it
->space_width
= Qnil
;
3853 it
->font_height
= Qnil
;
3856 /* We don't support recursive `display' properties, i.e. string
3857 values that have a string `display' property, that have a string
3858 `display' property etc. */
3859 if (!it
->string_from_display_prop_p
)
3860 it
->area
= TEXT_AREA
;
3862 prop
= get_char_property_and_overlay (make_number (position
->charpos
),
3863 Qdisplay
, object
, &overlay
);
3865 return HANDLED_NORMALLY
;
3866 /* Now OVERLAY is the overlay that gave us this property, or nil
3867 if it was a text property. */
3869 if (!STRINGP (it
->string
))
3870 object
= it
->w
->buffer
;
3873 /* Simple properties. */
3874 && !EQ (XCAR (prop
), Qimage
)
3875 && !EQ (XCAR (prop
), Qspace
)
3876 && !EQ (XCAR (prop
), Qwhen
)
3877 && !EQ (XCAR (prop
), Qslice
)
3878 && !EQ (XCAR (prop
), Qspace_width
)
3879 && !EQ (XCAR (prop
), Qheight
)
3880 && !EQ (XCAR (prop
), Qraise
)
3881 /* Marginal area specifications. */
3882 && !(CONSP (XCAR (prop
)) && EQ (XCAR (XCAR (prop
)), Qmargin
))
3883 && !EQ (XCAR (prop
), Qleft_fringe
)
3884 && !EQ (XCAR (prop
), Qright_fringe
)
3885 && !NILP (XCAR (prop
)))
3887 for (; CONSP (prop
); prop
= XCDR (prop
))
3889 if (handle_single_display_spec (it
, XCAR (prop
), object
, overlay
,
3890 position
, display_replaced_p
))
3892 display_replaced_p
= 1;
3893 /* If some text in a string is replaced, `position' no
3894 longer points to the position of `object'. */
3895 if (STRINGP (object
))
3900 else if (VECTORP (prop
))
3903 for (i
= 0; i
< ASIZE (prop
); ++i
)
3904 if (handle_single_display_spec (it
, AREF (prop
, i
), object
, overlay
,
3905 position
, display_replaced_p
))
3907 display_replaced_p
= 1;
3908 /* If some text in a string is replaced, `position' no
3909 longer points to the position of `object'. */
3910 if (STRINGP (object
))
3916 int ret
= handle_single_display_spec (it
, prop
, object
, overlay
,
3918 if (ret
< 0) /* Replaced by "", i.e. nothing. */
3919 return HANDLED_RECOMPUTE_PROPS
;
3921 display_replaced_p
= 1;
3924 return display_replaced_p
? HANDLED_RETURN
: HANDLED_NORMALLY
;
3928 /* Value is the position of the end of the `display' property starting
3929 at START_POS in OBJECT. */
3931 static struct text_pos
3932 display_prop_end (it
, object
, start_pos
)
3935 struct text_pos start_pos
;
3938 struct text_pos end_pos
;
3940 end
= Fnext_single_char_property_change (make_number (CHARPOS (start_pos
)),
3941 Qdisplay
, object
, Qnil
);
3942 CHARPOS (end_pos
) = XFASTINT (end
);
3943 if (STRINGP (object
))
3944 compute_string_pos (&end_pos
, start_pos
, it
->string
);
3946 BYTEPOS (end_pos
) = CHAR_TO_BYTE (XFASTINT (end
));
3952 /* Set up IT from a single `display' specification PROP. OBJECT
3953 is the object in which the `display' property was found. *POSITION
3954 is the position at which it was found. DISPLAY_REPLACED_P non-zero
3955 means that we previously saw a display specification which already
3956 replaced text display with something else, for example an image;
3957 we ignore such properties after the first one has been processed.
3959 OVERLAY is the overlay this `display' property came from,
3960 or nil if it was a text property.
3962 If PROP is a `space' or `image' specification, and in some other
3963 cases too, set *POSITION to the position where the `display'
3966 Value is non-zero if something was found which replaces the display
3967 of buffer or string text. Specifically, the value is -1 if that
3968 "something" is "nothing". */
3971 handle_single_display_spec (it
, spec
, object
, overlay
, position
,
3972 display_replaced_before_p
)
3976 Lisp_Object overlay
;
3977 struct text_pos
*position
;
3978 int display_replaced_before_p
;
3981 Lisp_Object location
, value
;
3982 struct text_pos start_pos
, save_pos
;
3985 /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
3986 If the result is non-nil, use VALUE instead of SPEC. */
3988 if (CONSP (spec
) && EQ (XCAR (spec
), Qwhen
))
3997 if (!NILP (form
) && !EQ (form
, Qt
))
3999 int count
= SPECPDL_INDEX ();
4000 struct gcpro gcpro1
;
4002 /* Bind `object' to the object having the `display' property, a
4003 buffer or string. Bind `position' to the position in the
4004 object where the property was found, and `buffer-position'
4005 to the current position in the buffer. */
4006 specbind (Qobject
, object
);
4007 specbind (Qposition
, make_number (CHARPOS (*position
)));
4008 specbind (Qbuffer_position
,
4009 make_number (STRINGP (object
)
4010 ? IT_CHARPOS (*it
) : CHARPOS (*position
)));
4012 form
= safe_eval (form
);
4014 unbind_to (count
, Qnil
);
4020 /* Handle `(height HEIGHT)' specifications. */
4022 && EQ (XCAR (spec
), Qheight
)
4023 && CONSP (XCDR (spec
)))
4025 if (!FRAME_WINDOW_P (it
->f
))
4028 it
->font_height
= XCAR (XCDR (spec
));
4029 if (!NILP (it
->font_height
))
4031 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4032 int new_height
= -1;
4034 if (CONSP (it
->font_height
)
4035 && (EQ (XCAR (it
->font_height
), Qplus
)
4036 || EQ (XCAR (it
->font_height
), Qminus
))
4037 && CONSP (XCDR (it
->font_height
))
4038 && INTEGERP (XCAR (XCDR (it
->font_height
))))
4040 /* `(+ N)' or `(- N)' where N is an integer. */
4041 int steps
= XINT (XCAR (XCDR (it
->font_height
)));
4042 if (EQ (XCAR (it
->font_height
), Qplus
))
4044 it
->face_id
= smaller_face (it
->f
, it
->face_id
, steps
);
4046 else if (FUNCTIONP (it
->font_height
))
4048 /* Call function with current height as argument.
4049 Value is the new height. */
4051 height
= safe_call1 (it
->font_height
,
4052 face
->lface
[LFACE_HEIGHT_INDEX
]);
4053 if (NUMBERP (height
))
4054 new_height
= XFLOATINT (height
);
4056 else if (NUMBERP (it
->font_height
))
4058 /* Value is a multiple of the canonical char height. */
4061 face
= FACE_FROM_ID (it
->f
, DEFAULT_FACE_ID
);
4062 new_height
= (XFLOATINT (it
->font_height
)
4063 * XINT (face
->lface
[LFACE_HEIGHT_INDEX
]));
4067 /* Evaluate IT->font_height with `height' bound to the
4068 current specified height to get the new height. */
4069 int count
= SPECPDL_INDEX ();
4071 specbind (Qheight
, face
->lface
[LFACE_HEIGHT_INDEX
]);
4072 value
= safe_eval (it
->font_height
);
4073 unbind_to (count
, Qnil
);
4075 if (NUMBERP (value
))
4076 new_height
= XFLOATINT (value
);
4080 it
->face_id
= face_with_height (it
->f
, it
->face_id
, new_height
);
4086 /* Handle `(space-width WIDTH)'. */
4088 && EQ (XCAR (spec
), Qspace_width
)
4089 && CONSP (XCDR (spec
)))
4091 if (!FRAME_WINDOW_P (it
->f
))
4094 value
= XCAR (XCDR (spec
));
4095 if (NUMBERP (value
) && XFLOATINT (value
) > 0)
4096 it
->space_width
= value
;
4101 /* Handle `(slice X Y WIDTH HEIGHT)'. */
4103 && EQ (XCAR (spec
), Qslice
))
4107 if (!FRAME_WINDOW_P (it
->f
))
4110 if (tem
= XCDR (spec
), CONSP (tem
))
4112 it
->slice
.x
= XCAR (tem
);
4113 if (tem
= XCDR (tem
), CONSP (tem
))
4115 it
->slice
.y
= XCAR (tem
);
4116 if (tem
= XCDR (tem
), CONSP (tem
))
4118 it
->slice
.width
= XCAR (tem
);
4119 if (tem
= XCDR (tem
), CONSP (tem
))
4120 it
->slice
.height
= XCAR (tem
);
4128 /* Handle `(raise FACTOR)'. */
4130 && EQ (XCAR (spec
), Qraise
)
4131 && CONSP (XCDR (spec
)))
4133 if (!FRAME_WINDOW_P (it
->f
))
4136 #ifdef HAVE_WINDOW_SYSTEM
4137 value
= XCAR (XCDR (spec
));
4138 if (NUMBERP (value
))
4140 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4141 it
->voffset
= - (XFLOATINT (value
)
4142 * (FONT_HEIGHT (face
->font
)));
4144 #endif /* HAVE_WINDOW_SYSTEM */
4149 /* Don't handle the other kinds of display specifications
4150 inside a string that we got from a `display' property. */
4151 if (it
->string_from_display_prop_p
)
4154 /* Characters having this form of property are not displayed, so
4155 we have to find the end of the property. */
4156 start_pos
= *position
;
4157 *position
= display_prop_end (it
, object
, start_pos
);
4160 /* Stop the scan at that end position--we assume that all
4161 text properties change there. */
4162 it
->stop_charpos
= position
->charpos
;
4164 /* Handle `(left-fringe BITMAP [FACE])'
4165 and `(right-fringe BITMAP [FACE])'. */
4167 && (EQ (XCAR (spec
), Qleft_fringe
)
4168 || EQ (XCAR (spec
), Qright_fringe
))
4169 && CONSP (XCDR (spec
)))
4171 int face_id
= DEFAULT_FACE_ID
;
4174 if (!FRAME_WINDOW_P (it
->f
))
4175 /* If we return here, POSITION has been advanced
4176 across the text with this property. */
4179 #ifdef HAVE_WINDOW_SYSTEM
4180 value
= XCAR (XCDR (spec
));
4181 if (!SYMBOLP (value
)
4182 || !(fringe_bitmap
= lookup_fringe_bitmap (value
)))
4183 /* If we return here, POSITION has been advanced
4184 across the text with this property. */
4187 if (CONSP (XCDR (XCDR (spec
))))
4189 Lisp_Object face_name
= XCAR (XCDR (XCDR (spec
)));
4190 int face_id2
= lookup_derived_face (it
->f
, face_name
,
4196 /* Save current settings of IT so that we can restore them
4197 when we are finished with the glyph property value. */
4199 save_pos
= it
->position
;
4200 it
->position
= *position
;
4202 it
->position
= save_pos
;
4204 it
->area
= TEXT_AREA
;
4205 it
->what
= IT_IMAGE
;
4206 it
->image_id
= -1; /* no image */
4207 it
->position
= start_pos
;
4208 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
4209 it
->method
= GET_FROM_IMAGE
;
4210 it
->from_overlay
= Qnil
;
4211 it
->face_id
= face_id
;
4213 /* Say that we haven't consumed the characters with
4214 `display' property yet. The call to pop_it in
4215 set_iterator_to_next will clean this up. */
4216 *position
= start_pos
;
4218 if (EQ (XCAR (spec
), Qleft_fringe
))
4220 it
->left_user_fringe_bitmap
= fringe_bitmap
;
4221 it
->left_user_fringe_face_id
= face_id
;
4225 it
->right_user_fringe_bitmap
= fringe_bitmap
;
4226 it
->right_user_fringe_face_id
= face_id
;
4228 #endif /* HAVE_WINDOW_SYSTEM */
4232 /* Prepare to handle `((margin left-margin) ...)',
4233 `((margin right-margin) ...)' and `((margin nil) ...)'
4234 prefixes for display specifications. */
4235 location
= Qunbound
;
4236 if (CONSP (spec
) && CONSP (XCAR (spec
)))
4240 value
= XCDR (spec
);
4242 value
= XCAR (value
);
4245 if (EQ (XCAR (tem
), Qmargin
)
4246 && (tem
= XCDR (tem
),
4247 tem
= CONSP (tem
) ? XCAR (tem
) : Qnil
,
4249 || EQ (tem
, Qleft_margin
)
4250 || EQ (tem
, Qright_margin
))))
4254 if (EQ (location
, Qunbound
))
4260 /* After this point, VALUE is the property after any
4261 margin prefix has been stripped. It must be a string,
4262 an image specification, or `(space ...)'.
4264 LOCATION specifies where to display: `left-margin',
4265 `right-margin' or nil. */
4267 valid_p
= (STRINGP (value
)
4268 #ifdef HAVE_WINDOW_SYSTEM
4269 || (FRAME_WINDOW_P (it
->f
) && valid_image_p (value
))
4270 #endif /* not HAVE_WINDOW_SYSTEM */
4271 || (CONSP (value
) && EQ (XCAR (value
), Qspace
)));
4273 if (valid_p
&& !display_replaced_before_p
)
4275 /* Save current settings of IT so that we can restore them
4276 when we are finished with the glyph property value. */
4277 save_pos
= it
->position
;
4278 it
->position
= *position
;
4280 it
->position
= save_pos
;
4281 it
->from_overlay
= overlay
;
4283 if (NILP (location
))
4284 it
->area
= TEXT_AREA
;
4285 else if (EQ (location
, Qleft_margin
))
4286 it
->area
= LEFT_MARGIN_AREA
;
4288 it
->area
= RIGHT_MARGIN_AREA
;
4290 if (STRINGP (value
))
4292 if (SCHARS (value
) == 0)
4295 return -1; /* Replaced by "", i.e. nothing. */
4298 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4299 it
->current
.overlay_string_index
= -1;
4300 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
4301 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
4302 it
->method
= GET_FROM_STRING
;
4303 it
->stop_charpos
= 0;
4304 it
->string_from_display_prop_p
= 1;
4305 /* Say that we haven't consumed the characters with
4306 `display' property yet. The call to pop_it in
4307 set_iterator_to_next will clean this up. */
4308 if (BUFFERP (object
))
4309 it
->current
.pos
= start_pos
;
4311 else if (CONSP (value
) && EQ (XCAR (value
), Qspace
))
4313 it
->method
= GET_FROM_STRETCH
;
4315 it
->position
= start_pos
;
4316 if (BUFFERP (object
))
4317 it
->current
.pos
= start_pos
;
4319 #ifdef HAVE_WINDOW_SYSTEM
4322 it
->what
= IT_IMAGE
;
4323 it
->image_id
= lookup_image (it
->f
, value
);
4324 it
->position
= start_pos
;
4325 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
4326 it
->method
= GET_FROM_IMAGE
;
4328 /* Say that we haven't consumed the characters with
4329 `display' property yet. The call to pop_it in
4330 set_iterator_to_next will clean this up. */
4331 if (BUFFERP (object
))
4332 it
->current
.pos
= start_pos
;
4334 #endif /* HAVE_WINDOW_SYSTEM */
4339 /* Invalid property or property not supported. Restore
4340 POSITION to what it was before. */
4341 *position
= start_pos
;
4346 /* Check if SPEC is a display sub-property value whose text should be
4347 treated as intangible. */
4350 single_display_spec_intangible_p (prop
)
4353 /* Skip over `when FORM'. */
4354 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
4368 /* Skip over `margin LOCATION'. If LOCATION is in the margins,
4369 we don't need to treat text as intangible. */
4370 if (EQ (XCAR (prop
), Qmargin
))
4378 || EQ (XCAR (prop
), Qleft_margin
)
4379 || EQ (XCAR (prop
), Qright_margin
))
4383 return (CONSP (prop
)
4384 && (EQ (XCAR (prop
), Qimage
)
4385 || EQ (XCAR (prop
), Qspace
)));
4389 /* Check if PROP is a display property value whose text should be
4390 treated as intangible. */
4393 display_prop_intangible_p (prop
)
4397 && CONSP (XCAR (prop
))
4398 && !EQ (Qmargin
, XCAR (XCAR (prop
))))
4400 /* A list of sub-properties. */
4401 while (CONSP (prop
))
4403 if (single_display_spec_intangible_p (XCAR (prop
)))
4408 else if (VECTORP (prop
))
4410 /* A vector of sub-properties. */
4412 for (i
= 0; i
< ASIZE (prop
); ++i
)
4413 if (single_display_spec_intangible_p (AREF (prop
, i
)))
4417 return single_display_spec_intangible_p (prop
);
4423 /* Return 1 if PROP is a display sub-property value containing STRING. */
4426 single_display_spec_string_p (prop
, string
)
4427 Lisp_Object prop
, string
;
4429 if (EQ (string
, prop
))
4432 /* Skip over `when FORM'. */
4433 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
4442 /* Skip over `margin LOCATION'. */
4443 if (EQ (XCAR (prop
), Qmargin
))
4454 return CONSP (prop
) && EQ (XCAR (prop
), string
);
4458 /* Return 1 if STRING appears in the `display' property PROP. */
4461 display_prop_string_p (prop
, string
)
4462 Lisp_Object prop
, string
;
4465 && CONSP (XCAR (prop
))
4466 && !EQ (Qmargin
, XCAR (XCAR (prop
))))
4468 /* A list of sub-properties. */
4469 while (CONSP (prop
))
4471 if (single_display_spec_string_p (XCAR (prop
), string
))
4476 else if (VECTORP (prop
))
4478 /* A vector of sub-properties. */
4480 for (i
= 0; i
< ASIZE (prop
); ++i
)
4481 if (single_display_spec_string_p (AREF (prop
, i
), string
))
4485 return single_display_spec_string_p (prop
, string
);
4491 /* Determine from which buffer position in W's buffer STRING comes
4492 from. AROUND_CHARPOS is an approximate position where it could
4493 be from. Value is the buffer position or 0 if it couldn't be
4496 W's buffer must be current.
4498 This function is necessary because we don't record buffer positions
4499 in glyphs generated from strings (to keep struct glyph small).
4500 This function may only use code that doesn't eval because it is
4501 called asynchronously from note_mouse_highlight. */
4504 string_buffer_position (w
, string
, around_charpos
)
4509 Lisp_Object limit
, prop
, pos
;
4510 const int MAX_DISTANCE
= 1000;
4513 pos
= make_number (around_charpos
);
4514 limit
= make_number (min (XINT (pos
) + MAX_DISTANCE
, ZV
));
4515 while (!found
&& !EQ (pos
, limit
))
4517 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
4518 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
4521 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, Qnil
, limit
);
4526 pos
= make_number (around_charpos
);
4527 limit
= make_number (max (XINT (pos
) - MAX_DISTANCE
, BEGV
));
4528 while (!found
&& !EQ (pos
, limit
))
4530 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
4531 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
4534 pos
= Fprevious_single_char_property_change (pos
, Qdisplay
, Qnil
,
4539 return found
? XINT (pos
) : 0;
4544 /***********************************************************************
4545 `composition' property
4546 ***********************************************************************/
4548 static enum prop_handled
4549 handle_auto_composed_prop (it
)
4552 enum prop_handled handled
= HANDLED_NORMALLY
;
4554 if (FUNCTIONP (Vauto_composition_function
))
4557 EMACS_INT pos
, this_pos
;
4559 if (STRINGP (it
->string
))
4560 pos
= IT_STRING_CHARPOS (*it
);
4562 pos
= IT_CHARPOS (*it
);
4565 val
=Fget_char_property (make_number (pos
), Qauto_composed
, it
->string
);
4568 Lisp_Object limit
= Qnil
, next
;
4570 /* As Fnext_single_char_property_change is very slow, we
4571 limit the search to the current line. */
4572 if (STRINGP (it
->string
))
4573 limit
= make_number (SCHARS (it
->string
));
4575 limit
= make_number (find_next_newline_no_quit (pos
, 1));
4577 next
= (Fnext_single_property_change
4578 (make_number (pos
), Qauto_composed
, it
->string
, limit
));
4579 if (XINT (next
) < XINT (limit
))
4581 /* The current point is auto-composed, but there exist
4582 characters not yet composed beyond the auto-composed
4583 region. There's a possiblity that the last
4584 characters in the region may be newly composed. */
4585 int charpos
= XINT (next
) - 1, bytepos
, c
;
4587 if (STRINGP (it
->string
))
4589 bytepos
= string_char_to_byte (it
->string
, charpos
);
4590 c
= SDATA (it
->string
)[bytepos
];
4594 bytepos
= CHAR_TO_BYTE (charpos
);
4595 c
= FETCH_BYTE (bytepos
);
4598 /* If the last character is not newline, it may be
4599 composed with the following characters. */
4600 val
= Qnil
, pos
= charpos
+ 1;
4605 int count
= SPECPDL_INDEX ();
4606 Lisp_Object args
[4];
4608 args
[0] = Vauto_composition_function
;
4609 specbind (Qauto_composition_function
, Qnil
);
4610 args
[1] = make_number (pos
);
4611 args
[2] = it
->string
;
4612 #ifdef USE_FONT_BACKEND
4613 if (enable_font_backend
)
4615 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4618 if (STRINGP (it
->string
))
4620 EMACS_INT pos_byte
= IT_STRING_BYTEPOS (*it
);
4621 const unsigned char *s
= SDATA (it
->string
) + pos_byte
;
4623 if (STRING_MULTIBYTE (it
->string
))
4624 it
->c
= STRING_CHAR (s
, 0);
4630 EMACS_INT pos_byte
= IT_BYTEPOS (*it
);
4632 it
->c
= FETCH_CHAR (pos_byte
);
4634 args
[3] = font_at (it
->c
, this_pos
, face
, it
->w
, it
->string
);
4637 #endif /* USE_FONT_BACKEND */
4639 safe_call (4, args
);
4640 unbind_to (count
, Qnil
);
4642 if (this_pos
== pos
)
4644 val
= Fget_char_property (args
[1], Qauto_composed
, it
->string
);
4645 /* Return HANDLED_RECOMPUTE_PROPS only if function composed
4646 something. This avoids an endless loop if they failed to
4647 fontify the text for which reason ever. */
4649 handled
= HANDLED_RECOMPUTE_PROPS
;
4652 handled
= HANDLED_RECOMPUTE_PROPS
;
4659 /* Set up iterator IT from `composition' property at its current
4660 position. Called from handle_stop. */
4662 static enum prop_handled
4663 handle_composition_prop (it
)
4666 Lisp_Object prop
, string
;
4667 EMACS_INT pos
, pos_byte
, start
, end
;
4668 enum prop_handled handled
= HANDLED_NORMALLY
;
4670 if (STRINGP (it
->string
))
4672 pos
= IT_STRING_CHARPOS (*it
);
4673 pos_byte
= IT_STRING_BYTEPOS (*it
);
4674 string
= it
->string
;
4678 pos
= IT_CHARPOS (*it
);
4679 pos_byte
= IT_BYTEPOS (*it
);
4683 /* If there's a valid composition and point is not inside of the
4684 composition (in the case that the composition is from the current
4685 buffer), draw a glyph composed from the composition components. */
4686 if (find_composition (pos
, -1, &start
, &end
, &prop
, string
)
4687 && COMPOSITION_VALID_P (start
, end
, prop
)
4688 && (STRINGP (it
->string
) || (PT
<= start
|| PT
>= end
)))
4694 if (STRINGP (it
->string
))
4695 pos_byte
= string_char_to_byte (it
->string
, start
);
4697 pos_byte
= CHAR_TO_BYTE (start
);
4699 id
= get_composition_id (start
, pos_byte
, end
- start
, prop
, string
);
4703 struct composition
*cmp
= composition_table
[id
];
4705 if (cmp
->glyph_len
== 0)
4708 if (STRINGP (it
->string
))
4710 IT_STRING_CHARPOS (*it
) = end
;
4711 IT_STRING_BYTEPOS (*it
) = string_char_to_byte (it
->string
,
4716 IT_CHARPOS (*it
) = end
;
4717 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (end
);
4719 return HANDLED_RECOMPUTE_PROPS
;
4722 it
->stop_charpos
= end
;
4725 it
->method
= GET_FROM_COMPOSITION
;
4727 it
->cmp_len
= COMPOSITION_LENGTH (prop
);
4728 /* For a terminal, draw only the first (non-TAB) character
4729 of the components. */
4730 #ifdef USE_FONT_BACKEND
4731 if (composition_table
[id
]->method
== COMPOSITION_WITH_GLYPH_STRING
)
4733 Lisp_Object lgstring
= AREF (XHASH_TABLE (composition_hash_table
)
4735 cmp
->hash_index
* 2);
4737 it
->c
= XINT (LGLYPH_CHAR (LGSTRING_GLYPH (lgstring
, 0)));
4740 #endif /* USE_FONT_BACKEND */
4744 for (i
= 0; i
< cmp
->glyph_len
; i
++)
4745 if ((it
->c
= COMPOSITION_GLYPH (composition_table
[id
], i
))
4751 it
->len
= (STRINGP (it
->string
)
4752 ? string_char_to_byte (it
->string
, end
)
4753 : CHAR_TO_BYTE (end
)) - pos_byte
;
4754 handled
= HANDLED_RETURN
;
4763 /***********************************************************************
4765 ***********************************************************************/
4767 /* The following structure is used to record overlay strings for
4768 later sorting in load_overlay_strings. */
4770 struct overlay_entry
4772 Lisp_Object overlay
;
4779 /* Set up iterator IT from overlay strings at its current position.
4780 Called from handle_stop. */
4782 static enum prop_handled
4783 handle_overlay_change (it
)
4786 if (!STRINGP (it
->string
) && get_overlay_strings (it
, 0))
4787 return HANDLED_RECOMPUTE_PROPS
;
4789 return HANDLED_NORMALLY
;
4793 /* Set up the next overlay string for delivery by IT, if there is an
4794 overlay string to deliver. Called by set_iterator_to_next when the
4795 end of the current overlay string is reached. If there are more
4796 overlay strings to display, IT->string and
4797 IT->current.overlay_string_index are set appropriately here.
4798 Otherwise IT->string is set to nil. */
4801 next_overlay_string (it
)
4804 ++it
->current
.overlay_string_index
;
4805 if (it
->current
.overlay_string_index
== it
->n_overlay_strings
)
4807 /* No more overlay strings. Restore IT's settings to what
4808 they were before overlay strings were processed, and
4809 continue to deliver from current_buffer. */
4810 int display_ellipsis_p
= it
->stack
[it
->sp
- 1].display_ellipsis_p
;
4814 || it
->method
== GET_FROM_COMPOSITION
4815 || (NILP (it
->string
)
4816 && it
->method
== GET_FROM_BUFFER
4817 && it
->stop_charpos
>= BEGV
4818 && it
->stop_charpos
<= it
->end_charpos
));
4819 it
->current
.overlay_string_index
= -1;
4820 it
->n_overlay_strings
= 0;
4822 /* If we're at the end of the buffer, record that we have
4823 processed the overlay strings there already, so that
4824 next_element_from_buffer doesn't try it again. */
4825 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
4826 it
->overlay_strings_at_end_processed_p
= 1;
4828 /* If we have to display `...' for invisible text, set
4829 the iterator up for that. */
4830 if (display_ellipsis_p
)
4831 setup_for_ellipsis (it
, 0);
4835 /* There are more overlay strings to process. If
4836 IT->current.overlay_string_index has advanced to a position
4837 where we must load IT->overlay_strings with more strings, do
4839 int i
= it
->current
.overlay_string_index
% OVERLAY_STRING_CHUNK_SIZE
;
4841 if (it
->current
.overlay_string_index
&& i
== 0)
4842 load_overlay_strings (it
, 0);
4844 /* Initialize IT to deliver display elements from the overlay
4846 it
->string
= it
->overlay_strings
[i
];
4847 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4848 SET_TEXT_POS (it
->current
.string_pos
, 0, 0);
4849 it
->method
= GET_FROM_STRING
;
4850 it
->stop_charpos
= 0;
4857 /* Compare two overlay_entry structures E1 and E2. Used as a
4858 comparison function for qsort in load_overlay_strings. Overlay
4859 strings for the same position are sorted so that
4861 1. All after-strings come in front of before-strings, except
4862 when they come from the same overlay.
4864 2. Within after-strings, strings are sorted so that overlay strings
4865 from overlays with higher priorities come first.
4867 2. Within before-strings, strings are sorted so that overlay
4868 strings from overlays with higher priorities come last.
4870 Value is analogous to strcmp. */
4874 compare_overlay_entries (e1
, e2
)
4877 struct overlay_entry
*entry1
= (struct overlay_entry
*) e1
;
4878 struct overlay_entry
*entry2
= (struct overlay_entry
*) e2
;
4881 if (entry1
->after_string_p
!= entry2
->after_string_p
)
4883 /* Let after-strings appear in front of before-strings if
4884 they come from different overlays. */
4885 if (EQ (entry1
->overlay
, entry2
->overlay
))
4886 result
= entry1
->after_string_p
? 1 : -1;
4888 result
= entry1
->after_string_p
? -1 : 1;
4890 else if (entry1
->after_string_p
)
4891 /* After-strings sorted in order of decreasing priority. */
4892 result
= entry2
->priority
- entry1
->priority
;
4894 /* Before-strings sorted in order of increasing priority. */
4895 result
= entry1
->priority
- entry2
->priority
;
4901 /* Load the vector IT->overlay_strings with overlay strings from IT's
4902 current buffer position, or from CHARPOS if that is > 0. Set
4903 IT->n_overlays to the total number of overlay strings found.
4905 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
4906 a time. On entry into load_overlay_strings,
4907 IT->current.overlay_string_index gives the number of overlay
4908 strings that have already been loaded by previous calls to this
4911 IT->add_overlay_start contains an additional overlay start
4912 position to consider for taking overlay strings from, if non-zero.
4913 This position comes into play when the overlay has an `invisible'
4914 property, and both before and after-strings. When we've skipped to
4915 the end of the overlay, because of its `invisible' property, we
4916 nevertheless want its before-string to appear.
4917 IT->add_overlay_start will contain the overlay start position
4920 Overlay strings are sorted so that after-string strings come in
4921 front of before-string strings. Within before and after-strings,
4922 strings are sorted by overlay priority. See also function
4923 compare_overlay_entries. */
4926 load_overlay_strings (it
, charpos
)
4930 extern Lisp_Object Qafter_string
, Qbefore_string
, Qwindow
, Qpriority
;
4931 Lisp_Object overlay
, window
, str
, invisible
;
4932 struct Lisp_Overlay
*ov
;
4935 int n
= 0, i
, j
, invis_p
;
4936 struct overlay_entry
*entries
4937 = (struct overlay_entry
*) alloca (size
* sizeof *entries
);
4940 charpos
= IT_CHARPOS (*it
);
4942 /* Append the overlay string STRING of overlay OVERLAY to vector
4943 `entries' which has size `size' and currently contains `n'
4944 elements. AFTER_P non-zero means STRING is an after-string of
4946 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
4949 Lisp_Object priority; \
4953 int new_size = 2 * size; \
4954 struct overlay_entry *old = entries; \
4956 (struct overlay_entry *) alloca (new_size \
4957 * sizeof *entries); \
4958 bcopy (old, entries, size * sizeof *entries); \
4962 entries[n].string = (STRING); \
4963 entries[n].overlay = (OVERLAY); \
4964 priority = Foverlay_get ((OVERLAY), Qpriority); \
4965 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
4966 entries[n].after_string_p = (AFTER_P); \
4971 /* Process overlay before the overlay center. */
4972 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
4974 XSETMISC (overlay
, ov
);
4975 xassert (OVERLAYP (overlay
));
4976 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4977 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4982 /* Skip this overlay if it doesn't start or end at IT's current
4984 if (end
!= charpos
&& start
!= charpos
)
4987 /* Skip this overlay if it doesn't apply to IT->w. */
4988 window
= Foverlay_get (overlay
, Qwindow
);
4989 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
4992 /* If the text ``under'' the overlay is invisible, both before-
4993 and after-strings from this overlay are visible; start and
4994 end position are indistinguishable. */
4995 invisible
= Foverlay_get (overlay
, Qinvisible
);
4996 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
4998 /* If overlay has a non-empty before-string, record it. */
4999 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5000 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5002 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5004 /* If overlay has a non-empty after-string, record it. */
5005 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5006 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5008 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5011 /* Process overlays after the overlay center. */
5012 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
5014 XSETMISC (overlay
, ov
);
5015 xassert (OVERLAYP (overlay
));
5016 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5017 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5019 if (start
> charpos
)
5022 /* Skip this overlay if it doesn't start or end at IT's current
5024 if (end
!= charpos
&& start
!= charpos
)
5027 /* Skip this overlay if it doesn't apply to IT->w. */
5028 window
= Foverlay_get (overlay
, Qwindow
);
5029 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5032 /* If the text ``under'' the overlay is invisible, it has a zero
5033 dimension, and both before- and after-strings apply. */
5034 invisible
= Foverlay_get (overlay
, Qinvisible
);
5035 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5037 /* If overlay has a non-empty before-string, record it. */
5038 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5039 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5041 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5043 /* If overlay has a non-empty after-string, record it. */
5044 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5045 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5047 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5050 #undef RECORD_OVERLAY_STRING
5054 qsort (entries
, n
, sizeof *entries
, compare_overlay_entries
);
5056 /* Record the total number of strings to process. */
5057 it
->n_overlay_strings
= n
;
5059 /* IT->current.overlay_string_index is the number of overlay strings
5060 that have already been consumed by IT. Copy some of the
5061 remaining overlay strings to IT->overlay_strings. */
5063 j
= it
->current
.overlay_string_index
;
5064 while (i
< OVERLAY_STRING_CHUNK_SIZE
&& j
< n
)
5066 it
->overlay_strings
[i
] = entries
[j
].string
;
5067 it
->string_overlays
[i
++] = entries
[j
++].overlay
;
5074 /* Get the first chunk of overlay strings at IT's current buffer
5075 position, or at CHARPOS if that is > 0. Value is non-zero if at
5076 least one overlay string was found. */
5079 get_overlay_strings_1 (it
, charpos
, compute_stop_p
)
5083 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
5084 process. This fills IT->overlay_strings with strings, and sets
5085 IT->n_overlay_strings to the total number of strings to process.
5086 IT->pos.overlay_string_index has to be set temporarily to zero
5087 because load_overlay_strings needs this; it must be set to -1
5088 when no overlay strings are found because a zero value would
5089 indicate a position in the first overlay string. */
5090 it
->current
.overlay_string_index
= 0;
5091 load_overlay_strings (it
, charpos
);
5093 /* If we found overlay strings, set up IT to deliver display
5094 elements from the first one. Otherwise set up IT to deliver
5095 from current_buffer. */
5096 if (it
->n_overlay_strings
)
5098 /* Make sure we know settings in current_buffer, so that we can
5099 restore meaningful values when we're done with the overlay
5102 compute_stop_pos (it
);
5103 xassert (it
->face_id
>= 0);
5105 /* Save IT's settings. They are restored after all overlay
5106 strings have been processed. */
5107 xassert (!compute_stop_p
|| it
->sp
== 0);
5110 /* Set up IT to deliver display elements from the first overlay
5112 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
5113 it
->string
= it
->overlay_strings
[0];
5114 it
->from_overlay
= Qnil
;
5115 it
->stop_charpos
= 0;
5116 xassert (STRINGP (it
->string
));
5117 it
->end_charpos
= SCHARS (it
->string
);
5118 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5119 it
->method
= GET_FROM_STRING
;
5123 it
->current
.overlay_string_index
= -1;
5128 get_overlay_strings (it
, charpos
)
5133 it
->method
= GET_FROM_BUFFER
;
5135 (void) get_overlay_strings_1 (it
, charpos
, 1);
5139 /* Value is non-zero if we found at least one overlay string. */
5140 return STRINGP (it
->string
);
5145 /***********************************************************************
5146 Saving and restoring state
5147 ***********************************************************************/
5149 /* Save current settings of IT on IT->stack. Called, for example,
5150 before setting up IT for an overlay string, to be able to restore
5151 IT's settings to what they were after the overlay string has been
5158 struct iterator_stack_entry
*p
;
5160 xassert (it
->sp
< IT_STACK_SIZE
);
5161 p
= it
->stack
+ it
->sp
;
5163 p
->stop_charpos
= it
->stop_charpos
;
5164 xassert (it
->face_id
>= 0);
5165 p
->face_id
= it
->face_id
;
5166 p
->string
= it
->string
;
5167 p
->method
= it
->method
;
5168 p
->from_overlay
= it
->from_overlay
;
5171 case GET_FROM_IMAGE
:
5172 p
->u
.image
.object
= it
->object
;
5173 p
->u
.image
.image_id
= it
->image_id
;
5174 p
->u
.image
.slice
= it
->slice
;
5176 case GET_FROM_COMPOSITION
:
5177 p
->u
.comp
.object
= it
->object
;
5178 p
->u
.comp
.c
= it
->c
;
5179 p
->u
.comp
.len
= it
->len
;
5180 p
->u
.comp
.cmp_id
= it
->cmp_id
;
5181 p
->u
.comp
.cmp_len
= it
->cmp_len
;
5183 case GET_FROM_STRETCH
:
5184 p
->u
.stretch
.object
= it
->object
;
5187 p
->position
= it
->position
;
5188 p
->current
= it
->current
;
5189 p
->end_charpos
= it
->end_charpos
;
5190 p
->string_nchars
= it
->string_nchars
;
5192 p
->multibyte_p
= it
->multibyte_p
;
5193 p
->space_width
= it
->space_width
;
5194 p
->font_height
= it
->font_height
;
5195 p
->voffset
= it
->voffset
;
5196 p
->string_from_display_prop_p
= it
->string_from_display_prop_p
;
5197 p
->display_ellipsis_p
= 0;
5202 /* Restore IT's settings from IT->stack. Called, for example, when no
5203 more overlay strings must be processed, and we return to delivering
5204 display elements from a buffer, or when the end of a string from a
5205 `display' property is reached and we return to delivering display
5206 elements from an overlay string, or from a buffer. */
5212 struct iterator_stack_entry
*p
;
5214 xassert (it
->sp
> 0);
5216 p
= it
->stack
+ it
->sp
;
5217 it
->stop_charpos
= p
->stop_charpos
;
5218 it
->face_id
= p
->face_id
;
5219 it
->current
= p
->current
;
5220 it
->position
= p
->position
;
5221 it
->string
= p
->string
;
5222 it
->from_overlay
= p
->from_overlay
;
5223 if (NILP (it
->string
))
5224 SET_TEXT_POS (it
->current
.string_pos
, -1, -1);
5225 it
->method
= p
->method
;
5228 case GET_FROM_IMAGE
:
5229 it
->image_id
= p
->u
.image
.image_id
;
5230 it
->object
= p
->u
.image
.object
;
5231 it
->slice
= p
->u
.image
.slice
;
5233 case GET_FROM_COMPOSITION
:
5234 it
->object
= p
->u
.comp
.object
;
5235 it
->c
= p
->u
.comp
.c
;
5236 it
->len
= p
->u
.comp
.len
;
5237 it
->cmp_id
= p
->u
.comp
.cmp_id
;
5238 it
->cmp_len
= p
->u
.comp
.cmp_len
;
5240 case GET_FROM_STRETCH
:
5241 it
->object
= p
->u
.comp
.object
;
5243 case GET_FROM_BUFFER
:
5244 it
->object
= it
->w
->buffer
;
5246 case GET_FROM_STRING
:
5247 it
->object
= it
->string
;
5250 it
->end_charpos
= p
->end_charpos
;
5251 it
->string_nchars
= p
->string_nchars
;
5253 it
->multibyte_p
= p
->multibyte_p
;
5254 it
->space_width
= p
->space_width
;
5255 it
->font_height
= p
->font_height
;
5256 it
->voffset
= p
->voffset
;
5257 it
->string_from_display_prop_p
= p
->string_from_display_prop_p
;
5262 /***********************************************************************
5264 ***********************************************************************/
5266 /* Set IT's current position to the previous line start. */
5269 back_to_previous_line_start (it
)
5272 IT_CHARPOS (*it
) = find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
5273 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (IT_CHARPOS (*it
));
5277 /* Move IT to the next line start.
5279 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
5280 we skipped over part of the text (as opposed to moving the iterator
5281 continuously over the text). Otherwise, don't change the value
5284 Newlines may come from buffer text, overlay strings, or strings
5285 displayed via the `display' property. That's the reason we can't
5286 simply use find_next_newline_no_quit.
5288 Note that this function may not skip over invisible text that is so
5289 because of text properties and immediately follows a newline. If
5290 it would, function reseat_at_next_visible_line_start, when called
5291 from set_iterator_to_next, would effectively make invisible
5292 characters following a newline part of the wrong glyph row, which
5293 leads to wrong cursor motion. */
5296 forward_to_next_line_start (it
, skipped_p
)
5300 int old_selective
, newline_found_p
, n
;
5301 const int MAX_NEWLINE_DISTANCE
= 500;
5303 /* If already on a newline, just consume it to avoid unintended
5304 skipping over invisible text below. */
5305 if (it
->what
== IT_CHARACTER
5307 && CHARPOS (it
->position
) == IT_CHARPOS (*it
))
5309 set_iterator_to_next (it
, 0);
5314 /* Don't handle selective display in the following. It's (a)
5315 unnecessary because it's done by the caller, and (b) leads to an
5316 infinite recursion because next_element_from_ellipsis indirectly
5317 calls this function. */
5318 old_selective
= it
->selective
;
5321 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
5322 from buffer text. */
5323 for (n
= newline_found_p
= 0;
5324 !newline_found_p
&& n
< MAX_NEWLINE_DISTANCE
;
5325 n
+= STRINGP (it
->string
) ? 0 : 1)
5327 if (!get_next_display_element (it
))
5329 newline_found_p
= it
->what
== IT_CHARACTER
&& it
->c
== '\n';
5330 set_iterator_to_next (it
, 0);
5333 /* If we didn't find a newline near enough, see if we can use a
5335 if (!newline_found_p
)
5337 int start
= IT_CHARPOS (*it
);
5338 int limit
= find_next_newline_no_quit (start
, 1);
5341 xassert (!STRINGP (it
->string
));
5343 /* If there isn't any `display' property in sight, and no
5344 overlays, we can just use the position of the newline in
5346 if (it
->stop_charpos
>= limit
5347 || ((pos
= Fnext_single_property_change (make_number (start
),
5349 Qnil
, make_number (limit
)),
5351 && next_overlay_change (start
) == ZV
))
5353 IT_CHARPOS (*it
) = limit
;
5354 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (limit
);
5355 *skipped_p
= newline_found_p
= 1;
5359 while (get_next_display_element (it
)
5360 && !newline_found_p
)
5362 newline_found_p
= ITERATOR_AT_END_OF_LINE_P (it
);
5363 set_iterator_to_next (it
, 0);
5368 it
->selective
= old_selective
;
5369 return newline_found_p
;
5373 /* Set IT's current position to the previous visible line start. Skip
5374 invisible text that is so either due to text properties or due to
5375 selective display. Caution: this does not change IT->current_x and
5379 back_to_previous_visible_line_start (it
)
5382 while (IT_CHARPOS (*it
) > BEGV
)
5384 back_to_previous_line_start (it
);
5386 if (IT_CHARPOS (*it
) <= BEGV
)
5389 /* If selective > 0, then lines indented more than that values
5391 if (it
->selective
> 0
5392 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
5393 (double) it
->selective
)) /* iftc */
5396 /* Check the newline before point for invisibility. */
5399 prop
= Fget_char_property (make_number (IT_CHARPOS (*it
) - 1),
5400 Qinvisible
, it
->window
);
5401 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
5405 if (IT_CHARPOS (*it
) <= BEGV
)
5412 Lisp_Object val
, overlay
;
5414 /* If newline is part of a composition, continue from start of composition */
5415 if (find_composition (IT_CHARPOS (*it
), -1, &beg
, &end
, &val
, Qnil
)
5416 && beg
< IT_CHARPOS (*it
))
5419 /* If newline is replaced by a display property, find start of overlay
5420 or interval and continue search from that point. */
5422 pos
= --IT_CHARPOS (it2
);
5425 if (handle_display_prop (&it2
) == HANDLED_RETURN
5426 && !NILP (val
= get_char_property_and_overlay
5427 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
5428 && (OVERLAYP (overlay
)
5429 ? (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)))
5430 : get_property_and_range (pos
, Qdisplay
, &val
, &beg
, &end
, Qnil
)))
5433 /* Newline is not replaced by anything -- so we are done. */
5439 IT_CHARPOS (*it
) = beg
;
5440 IT_BYTEPOS (*it
) = buf_charpos_to_bytepos (current_buffer
, beg
);
5444 it
->continuation_lines_width
= 0;
5446 xassert (IT_CHARPOS (*it
) >= BEGV
);
5447 xassert (IT_CHARPOS (*it
) == BEGV
5448 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
5453 /* Reseat iterator IT at the previous visible line start. Skip
5454 invisible text that is so either due to text properties or due to
5455 selective display. At the end, update IT's overlay information,
5456 face information etc. */
5459 reseat_at_previous_visible_line_start (it
)
5462 back_to_previous_visible_line_start (it
);
5463 reseat (it
, it
->current
.pos
, 1);
5468 /* Reseat iterator IT on the next visible line start in the current
5469 buffer. ON_NEWLINE_P non-zero means position IT on the newline
5470 preceding the line start. Skip over invisible text that is so
5471 because of selective display. Compute faces, overlays etc at the
5472 new position. Note that this function does not skip over text that
5473 is invisible because of text properties. */
5476 reseat_at_next_visible_line_start (it
, on_newline_p
)
5480 int newline_found_p
, skipped_p
= 0;
5482 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
5484 /* Skip over lines that are invisible because they are indented
5485 more than the value of IT->selective. */
5486 if (it
->selective
> 0)
5487 while (IT_CHARPOS (*it
) < ZV
5488 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
5489 (double) it
->selective
)) /* iftc */
5491 xassert (IT_BYTEPOS (*it
) == BEGV
5492 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
5493 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
5496 /* Position on the newline if that's what's requested. */
5497 if (on_newline_p
&& newline_found_p
)
5499 if (STRINGP (it
->string
))
5501 if (IT_STRING_CHARPOS (*it
) > 0)
5503 --IT_STRING_CHARPOS (*it
);
5504 --IT_STRING_BYTEPOS (*it
);
5507 else if (IT_CHARPOS (*it
) > BEGV
)
5511 reseat (it
, it
->current
.pos
, 0);
5515 reseat (it
, it
->current
.pos
, 0);
5522 /***********************************************************************
5523 Changing an iterator's position
5524 ***********************************************************************/
5526 /* Change IT's current position to POS in current_buffer. If FORCE_P
5527 is non-zero, always check for text properties at the new position.
5528 Otherwise, text properties are only looked up if POS >=
5529 IT->check_charpos of a property. */
5532 reseat (it
, pos
, force_p
)
5534 struct text_pos pos
;
5537 int original_pos
= IT_CHARPOS (*it
);
5539 reseat_1 (it
, pos
, 0);
5541 /* Determine where to check text properties. Avoid doing it
5542 where possible because text property lookup is very expensive. */
5544 || CHARPOS (pos
) > it
->stop_charpos
5545 || CHARPOS (pos
) < original_pos
)
5552 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
5553 IT->stop_pos to POS, also. */
5556 reseat_1 (it
, pos
, set_stop_p
)
5558 struct text_pos pos
;
5561 /* Don't call this function when scanning a C string. */
5562 xassert (it
->s
== NULL
);
5564 /* POS must be a reasonable value. */
5565 xassert (CHARPOS (pos
) >= BEGV
&& CHARPOS (pos
) <= ZV
);
5567 it
->current
.pos
= it
->position
= pos
;
5568 it
->end_charpos
= ZV
;
5570 it
->current
.dpvec_index
= -1;
5571 it
->current
.overlay_string_index
= -1;
5572 IT_STRING_CHARPOS (*it
) = -1;
5573 IT_STRING_BYTEPOS (*it
) = -1;
5575 it
->method
= GET_FROM_BUFFER
;
5576 it
->object
= it
->w
->buffer
;
5577 it
->area
= TEXT_AREA
;
5578 it
->multibyte_p
= !NILP (current_buffer
->enable_multibyte_characters
);
5580 it
->string_from_display_prop_p
= 0;
5581 it
->face_before_selective_p
= 0;
5584 it
->stop_charpos
= CHARPOS (pos
);
5588 /* Set up IT for displaying a string, starting at CHARPOS in window W.
5589 If S is non-null, it is a C string to iterate over. Otherwise,
5590 STRING gives a Lisp string to iterate over.
5592 If PRECISION > 0, don't return more then PRECISION number of
5593 characters from the string.
5595 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
5596 characters have been returned. FIELD_WIDTH < 0 means an infinite
5599 MULTIBYTE = 0 means disable processing of multibyte characters,
5600 MULTIBYTE > 0 means enable it,
5601 MULTIBYTE < 0 means use IT->multibyte_p.
5603 IT must be initialized via a prior call to init_iterator before
5604 calling this function. */
5607 reseat_to_string (it
, s
, string
, charpos
, precision
, field_width
, multibyte
)
5612 int precision
, field_width
, multibyte
;
5614 /* No region in strings. */
5615 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
5617 /* No text property checks performed by default, but see below. */
5618 it
->stop_charpos
= -1;
5620 /* Set iterator position and end position. */
5621 bzero (&it
->current
, sizeof it
->current
);
5622 it
->current
.overlay_string_index
= -1;
5623 it
->current
.dpvec_index
= -1;
5624 xassert (charpos
>= 0);
5626 /* If STRING is specified, use its multibyteness, otherwise use the
5627 setting of MULTIBYTE, if specified. */
5629 it
->multibyte_p
= multibyte
> 0;
5633 xassert (STRINGP (string
));
5634 it
->string
= string
;
5636 it
->end_charpos
= it
->string_nchars
= SCHARS (string
);
5637 it
->method
= GET_FROM_STRING
;
5638 it
->current
.string_pos
= string_pos (charpos
, string
);
5645 /* Note that we use IT->current.pos, not it->current.string_pos,
5646 for displaying C strings. */
5647 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
5648 if (it
->multibyte_p
)
5650 it
->current
.pos
= c_string_pos (charpos
, s
, 1);
5651 it
->end_charpos
= it
->string_nchars
= number_of_chars (s
, 1);
5655 IT_CHARPOS (*it
) = IT_BYTEPOS (*it
) = charpos
;
5656 it
->end_charpos
= it
->string_nchars
= strlen (s
);
5659 it
->method
= GET_FROM_C_STRING
;
5662 /* PRECISION > 0 means don't return more than PRECISION characters
5664 if (precision
> 0 && it
->end_charpos
- charpos
> precision
)
5665 it
->end_charpos
= it
->string_nchars
= charpos
+ precision
;
5667 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
5668 characters have been returned. FIELD_WIDTH == 0 means don't pad,
5669 FIELD_WIDTH < 0 means infinite field width. This is useful for
5670 padding with `-' at the end of a mode line. */
5671 if (field_width
< 0)
5672 field_width
= INFINITY
;
5673 if (field_width
> it
->end_charpos
- charpos
)
5674 it
->end_charpos
= charpos
+ field_width
;
5676 /* Use the standard display table for displaying strings. */
5677 if (DISP_TABLE_P (Vstandard_display_table
))
5678 it
->dp
= XCHAR_TABLE (Vstandard_display_table
);
5680 it
->stop_charpos
= charpos
;
5686 /***********************************************************************
5688 ***********************************************************************/
5690 /* Map enum it_method value to corresponding next_element_from_* function. */
5692 static int (* get_next_element
[NUM_IT_METHODS
]) P_ ((struct it
*it
)) =
5694 next_element_from_buffer
,
5695 next_element_from_display_vector
,
5696 next_element_from_composition
,
5697 next_element_from_string
,
5698 next_element_from_c_string
,
5699 next_element_from_image
,
5700 next_element_from_stretch
5704 /* Load IT's display element fields with information about the next
5705 display element from the current position of IT. Value is zero if
5706 end of buffer (or C string) is reached. */
5708 static struct frame
*last_escape_glyph_frame
= NULL
;
5709 static unsigned last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
5710 static int last_escape_glyph_merged_face_id
= 0;
5713 get_next_display_element (it
)
5716 /* Non-zero means that we found a display element. Zero means that
5717 we hit the end of what we iterate over. Performance note: the
5718 function pointer `method' used here turns out to be faster than
5719 using a sequence of if-statements. */
5723 success_p
= (*get_next_element
[it
->method
]) (it
);
5725 if (it
->what
== IT_CHARACTER
)
5727 /* Map via display table or translate control characters.
5728 IT->c, IT->len etc. have been set to the next character by
5729 the function call above. If we have a display table, and it
5730 contains an entry for IT->c, translate it. Don't do this if
5731 IT->c itself comes from a display table, otherwise we could
5732 end up in an infinite recursion. (An alternative could be to
5733 count the recursion depth of this function and signal an
5734 error when a certain maximum depth is reached.) Is it worth
5736 if (success_p
&& it
->dpvec
== NULL
)
5741 && (dv
= DISP_CHAR_VECTOR (it
->dp
, it
->c
),
5744 struct Lisp_Vector
*v
= XVECTOR (dv
);
5746 /* Return the first character from the display table
5747 entry, if not empty. If empty, don't display the
5748 current character. */
5751 it
->dpvec_char_len
= it
->len
;
5752 it
->dpvec
= v
->contents
;
5753 it
->dpend
= v
->contents
+ v
->size
;
5754 it
->current
.dpvec_index
= 0;
5755 it
->dpvec_face_id
= -1;
5756 it
->saved_face_id
= it
->face_id
;
5757 it
->method
= GET_FROM_DISPLAY_VECTOR
;
5762 set_iterator_to_next (it
, 0);
5767 /* Translate control characters into `\003' or `^C' form.
5768 Control characters coming from a display table entry are
5769 currently not translated because we use IT->dpvec to hold
5770 the translation. This could easily be changed but I
5771 don't believe that it is worth doing.
5773 If it->multibyte_p is nonzero, non-printable non-ASCII
5774 characters are also translated to octal form.
5776 If it->multibyte_p is zero, eight-bit characters that
5777 don't have corresponding multibyte char code are also
5778 translated to octal form. */
5779 else if ((it
->c
< ' '
5780 ? (it
->area
!= TEXT_AREA
5781 /* In mode line, treat \n, \t like other crl chars. */
5783 && it
->glyph_row
&& it
->glyph_row
->mode_line_p
)
5784 || (it
->c
!= '\n' && it
->c
!= '\t'))
5786 ? (!CHAR_PRINTABLE_P (it
->c
)
5787 || (!NILP (Vnobreak_char_display
)
5788 && (it
->c
== 0xA0 /* NO-BREAK SPACE */
5789 || it
->c
== 0xAD /* SOFT HYPHEN */)))
5791 && (! unibyte_display_via_language_environment
5792 || (UNIBYTE_CHAR_HAS_MULTIBYTE_P (it
->c
)))))))
5794 /* IT->c is a control character which must be displayed
5795 either as '\003' or as `^C' where the '\\' and '^'
5796 can be defined in the display table. Fill
5797 IT->ctl_chars with glyphs for what we have to
5798 display. Then, set IT->dpvec to these glyphs. */
5801 int face_id
, lface_id
= 0 ;
5804 /* Handle control characters with ^. */
5806 if (it
->c
< 128 && it
->ctl_arrow_p
)
5808 g
= '^'; /* default glyph for Control */
5809 /* Set IT->ctl_chars[0] to the glyph for `^'. */
5811 && INTEGERP (DISP_CTRL_GLYPH (it
->dp
))
5812 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (it
->dp
))))
5814 g
= XINT (DISP_CTRL_GLYPH (it
->dp
));
5815 lface_id
= FAST_GLYPH_FACE (g
);
5819 g
= FAST_GLYPH_CHAR (g
);
5820 face_id
= merge_faces (it
->f
, Qt
, lface_id
,
5823 else if (it
->f
== last_escape_glyph_frame
5824 && it
->face_id
== last_escape_glyph_face_id
)
5826 face_id
= last_escape_glyph_merged_face_id
;
5830 /* Merge the escape-glyph face into the current face. */
5831 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
5833 last_escape_glyph_frame
= it
->f
;
5834 last_escape_glyph_face_id
= it
->face_id
;
5835 last_escape_glyph_merged_face_id
= face_id
;
5838 XSETINT (it
->ctl_chars
[0], g
);
5840 XSETINT (it
->ctl_chars
[1], g
);
5842 goto display_control
;
5845 /* Handle non-break space in the mode where it only gets
5848 if (EQ (Vnobreak_char_display
, Qt
)
5851 /* Merge the no-break-space face into the current face. */
5852 face_id
= merge_faces (it
->f
, Qnobreak_space
, 0,
5856 XSETINT (it
->ctl_chars
[0], g
);
5858 goto display_control
;
5861 /* Handle sequences that start with the "escape glyph". */
5863 /* the default escape glyph is \. */
5864 escape_glyph
= '\\';
5867 && INTEGERP (DISP_ESCAPE_GLYPH (it
->dp
))
5868 && GLYPH_CHAR_VALID_P (XFASTINT (DISP_ESCAPE_GLYPH (it
->dp
))))
5870 escape_glyph
= XFASTINT (DISP_ESCAPE_GLYPH (it
->dp
));
5871 lface_id
= FAST_GLYPH_FACE (escape_glyph
);
5875 /* The display table specified a face.
5876 Merge it into face_id and also into escape_glyph. */
5877 escape_glyph
= FAST_GLYPH_CHAR (escape_glyph
);
5878 face_id
= merge_faces (it
->f
, Qt
, lface_id
,
5881 else if (it
->f
== last_escape_glyph_frame
5882 && it
->face_id
== last_escape_glyph_face_id
)
5884 face_id
= last_escape_glyph_merged_face_id
;
5888 /* Merge the escape-glyph face into the current face. */
5889 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
5891 last_escape_glyph_frame
= it
->f
;
5892 last_escape_glyph_face_id
= it
->face_id
;
5893 last_escape_glyph_merged_face_id
= face_id
;
5896 /* Handle soft hyphens in the mode where they only get
5899 if (EQ (Vnobreak_char_display
, Qt
)
5903 XSETINT (it
->ctl_chars
[0], g
);
5905 goto display_control
;
5908 /* Handle non-break space and soft hyphen
5909 with the escape glyph. */
5911 if (it
->c
== 0xA0 || it
->c
== 0xAD)
5913 XSETINT (it
->ctl_chars
[0], escape_glyph
);
5914 g
= it
->c
= (it
->c
== 0xA0 ? ' ' : '-');
5915 XSETINT (it
->ctl_chars
[1], g
);
5917 goto display_control
;
5921 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
5925 /* Set IT->ctl_chars[0] to the glyph for `\\'. */
5926 if (CHAR_BYTE8_P (it
->c
))
5928 str
[0] = CHAR_TO_BYTE8 (it
->c
);
5931 else if (it
->c
< 256)
5938 /* It's an invalid character, which shouldn't
5939 happen actually, but due to bugs it may
5940 happen. Let's print the char as is, there's
5941 not much meaningful we can do with it. */
5943 str
[1] = it
->c
>> 8;
5944 str
[2] = it
->c
>> 16;
5945 str
[3] = it
->c
>> 24;
5949 for (i
= 0; i
< len
; i
++)
5951 XSETINT (it
->ctl_chars
[i
* 4], escape_glyph
);
5952 /* Insert three more glyphs into IT->ctl_chars for
5953 the octal display of the character. */
5954 g
= ((str
[i
] >> 6) & 7) + '0';
5955 XSETINT (it
->ctl_chars
[i
* 4 + 1], g
);
5956 g
= ((str
[i
] >> 3) & 7) + '0';
5957 XSETINT (it
->ctl_chars
[i
* 4 + 2], g
);
5958 g
= (str
[i
] & 7) + '0';
5959 XSETINT (it
->ctl_chars
[i
* 4 + 3], g
);
5965 /* Set up IT->dpvec and return first character from it. */
5966 it
->dpvec_char_len
= it
->len
;
5967 it
->dpvec
= it
->ctl_chars
;
5968 it
->dpend
= it
->dpvec
+ ctl_len
;
5969 it
->current
.dpvec_index
= 0;
5970 it
->dpvec_face_id
= face_id
;
5971 it
->saved_face_id
= it
->face_id
;
5972 it
->method
= GET_FROM_DISPLAY_VECTOR
;
5979 /* Adjust face id for a multibyte character. There are no multibyte
5980 character in unibyte text. */
5981 if ((it
->what
== IT_CHARACTER
|| it
->what
== IT_COMPOSITION
)
5984 && FRAME_WINDOW_P (it
->f
))
5986 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
5987 int pos
= (it
->s
? -1
5988 : STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
5989 : IT_CHARPOS (*it
));
5991 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->c
, pos
, it
->string
);
5994 /* Is this character the last one of a run of characters with
5995 box? If yes, set IT->end_of_box_run_p to 1. */
6002 it
->end_of_box_run_p
6003 = ((face_id
= face_after_it_pos (it
),
6004 face_id
!= it
->face_id
)
6005 && (face
= FACE_FROM_ID (it
->f
, face_id
),
6006 face
->box
== FACE_NO_BOX
));
6009 /* Value is 0 if end of buffer or string reached. */
6014 /* Move IT to the next display element.
6016 RESEAT_P non-zero means if called on a newline in buffer text,
6017 skip to the next visible line start.
6019 Functions get_next_display_element and set_iterator_to_next are
6020 separate because I find this arrangement easier to handle than a
6021 get_next_display_element function that also increments IT's
6022 position. The way it is we can first look at an iterator's current
6023 display element, decide whether it fits on a line, and if it does,
6024 increment the iterator position. The other way around we probably
6025 would either need a flag indicating whether the iterator has to be
6026 incremented the next time, or we would have to implement a
6027 decrement position function which would not be easy to write. */
6030 set_iterator_to_next (it
, reseat_p
)
6034 /* Reset flags indicating start and end of a sequence of characters
6035 with box. Reset them at the start of this function because
6036 moving the iterator to a new position might set them. */
6037 it
->start_of_box_run_p
= it
->end_of_box_run_p
= 0;
6041 case GET_FROM_BUFFER
:
6042 /* The current display element of IT is a character from
6043 current_buffer. Advance in the buffer, and maybe skip over
6044 invisible lines that are so because of selective display. */
6045 if (ITERATOR_AT_END_OF_LINE_P (it
) && reseat_p
)
6046 reseat_at_next_visible_line_start (it
, 0);
6049 xassert (it
->len
!= 0);
6050 IT_BYTEPOS (*it
) += it
->len
;
6051 IT_CHARPOS (*it
) += 1;
6052 xassert (IT_BYTEPOS (*it
) == CHAR_TO_BYTE (IT_CHARPOS (*it
)));
6056 case GET_FROM_COMPOSITION
:
6057 xassert (it
->cmp_id
>= 0 && it
->cmp_id
< n_compositions
);
6058 xassert (it
->sp
> 0);
6060 if (it
->method
== GET_FROM_STRING
)
6062 IT_STRING_BYTEPOS (*it
) += it
->len
;
6063 IT_STRING_CHARPOS (*it
) += it
->cmp_len
;
6064 goto consider_string_end
;
6066 else if (it
->method
== GET_FROM_BUFFER
)
6068 IT_BYTEPOS (*it
) += it
->len
;
6069 IT_CHARPOS (*it
) += it
->cmp_len
;
6073 case GET_FROM_C_STRING
:
6074 /* Current display element of IT is from a C string. */
6075 IT_BYTEPOS (*it
) += it
->len
;
6076 IT_CHARPOS (*it
) += 1;
6079 case GET_FROM_DISPLAY_VECTOR
:
6080 /* Current display element of IT is from a display table entry.
6081 Advance in the display table definition. Reset it to null if
6082 end reached, and continue with characters from buffers/
6084 ++it
->current
.dpvec_index
;
6086 /* Restore face of the iterator to what they were before the
6087 display vector entry (these entries may contain faces). */
6088 it
->face_id
= it
->saved_face_id
;
6090 if (it
->dpvec
+ it
->current
.dpvec_index
== it
->dpend
)
6092 int recheck_faces
= it
->ellipsis_p
;
6095 it
->method
= GET_FROM_C_STRING
;
6096 else if (STRINGP (it
->string
))
6097 it
->method
= GET_FROM_STRING
;
6100 it
->method
= GET_FROM_BUFFER
;
6101 it
->object
= it
->w
->buffer
;
6105 it
->current
.dpvec_index
= -1;
6107 /* Skip over characters which were displayed via IT->dpvec. */
6108 if (it
->dpvec_char_len
< 0)
6109 reseat_at_next_visible_line_start (it
, 1);
6110 else if (it
->dpvec_char_len
> 0)
6112 if (it
->method
== GET_FROM_STRING
6113 && it
->n_overlay_strings
> 0)
6114 it
->ignore_overlay_strings_at_pos_p
= 1;
6115 it
->len
= it
->dpvec_char_len
;
6116 set_iterator_to_next (it
, reseat_p
);
6119 /* Maybe recheck faces after display vector */
6121 it
->stop_charpos
= IT_CHARPOS (*it
);
6125 case GET_FROM_STRING
:
6126 /* Current display element is a character from a Lisp string. */
6127 xassert (it
->s
== NULL
&& STRINGP (it
->string
));
6128 IT_STRING_BYTEPOS (*it
) += it
->len
;
6129 IT_STRING_CHARPOS (*it
) += 1;
6131 consider_string_end
:
6133 if (it
->current
.overlay_string_index
>= 0)
6135 /* IT->string is an overlay string. Advance to the
6136 next, if there is one. */
6137 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
6138 next_overlay_string (it
);
6142 /* IT->string is not an overlay string. If we reached
6143 its end, and there is something on IT->stack, proceed
6144 with what is on the stack. This can be either another
6145 string, this time an overlay string, or a buffer. */
6146 if (IT_STRING_CHARPOS (*it
) == SCHARS (it
->string
)
6150 if (it
->method
== GET_FROM_STRING
)
6151 goto consider_string_end
;
6156 case GET_FROM_IMAGE
:
6157 case GET_FROM_STRETCH
:
6158 /* The position etc with which we have to proceed are on
6159 the stack. The position may be at the end of a string,
6160 if the `display' property takes up the whole string. */
6161 xassert (it
->sp
> 0);
6163 if (it
->method
== GET_FROM_STRING
)
6164 goto consider_string_end
;
6168 /* There are no other methods defined, so this should be a bug. */
6172 xassert (it
->method
!= GET_FROM_STRING
6173 || (STRINGP (it
->string
)
6174 && IT_STRING_CHARPOS (*it
) >= 0));
6177 /* Load IT's display element fields with information about the next
6178 display element which comes from a display table entry or from the
6179 result of translating a control character to one of the forms `^C'
6182 IT->dpvec holds the glyphs to return as characters.
6183 IT->saved_face_id holds the face id before the display vector--
6184 it is restored into IT->face_idin set_iterator_to_next. */
6187 next_element_from_display_vector (it
)
6191 xassert (it
->dpvec
&& it
->current
.dpvec_index
>= 0);
6193 it
->face_id
= it
->saved_face_id
;
6195 if (INTEGERP (*it
->dpvec
)
6196 && GLYPH_CHAR_VALID_P (XFASTINT (*it
->dpvec
)))
6200 g
= XFASTINT (it
->dpvec
[it
->current
.dpvec_index
]);
6201 it
->c
= FAST_GLYPH_CHAR (g
);
6202 it
->len
= CHAR_BYTES (it
->c
);
6204 /* The entry may contain a face id to use. Such a face id is
6205 the id of a Lisp face, not a realized face. A face id of
6206 zero means no face is specified. */
6207 if (it
->dpvec_face_id
>= 0)
6208 it
->face_id
= it
->dpvec_face_id
;
6211 int lface_id
= FAST_GLYPH_FACE (g
);
6213 it
->face_id
= merge_faces (it
->f
, Qt
, lface_id
,
6218 /* Display table entry is invalid. Return a space. */
6219 it
->c
= ' ', it
->len
= 1;
6221 /* Don't change position and object of the iterator here. They are
6222 still the values of the character that had this display table
6223 entry or was translated, and that's what we want. */
6224 it
->what
= IT_CHARACTER
;
6229 /* Load IT with the next display element from Lisp string IT->string.
6230 IT->current.string_pos is the current position within the string.
6231 If IT->current.overlay_string_index >= 0, the Lisp string is an
6235 next_element_from_string (it
)
6238 struct text_pos position
;
6240 xassert (STRINGP (it
->string
));
6241 xassert (IT_STRING_CHARPOS (*it
) >= 0);
6242 position
= it
->current
.string_pos
;
6244 /* Time to check for invisible text? */
6245 if (IT_STRING_CHARPOS (*it
) < it
->end_charpos
6246 && IT_STRING_CHARPOS (*it
) == it
->stop_charpos
)
6250 /* Since a handler may have changed IT->method, we must
6252 return get_next_display_element (it
);
6255 if (it
->current
.overlay_string_index
>= 0)
6257 /* Get the next character from an overlay string. In overlay
6258 strings, There is no field width or padding with spaces to
6260 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
6265 else if (STRING_MULTIBYTE (it
->string
))
6267 int remaining
= SBYTES (it
->string
) - IT_STRING_BYTEPOS (*it
);
6268 const unsigned char *s
= (SDATA (it
->string
)
6269 + IT_STRING_BYTEPOS (*it
));
6270 it
->c
= string_char_and_length (s
, remaining
, &it
->len
);
6274 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
6280 /* Get the next character from a Lisp string that is not an
6281 overlay string. Such strings come from the mode line, for
6282 example. We may have to pad with spaces, or truncate the
6283 string. See also next_element_from_c_string. */
6284 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
6289 else if (IT_STRING_CHARPOS (*it
) >= it
->string_nchars
)
6291 /* Pad with spaces. */
6292 it
->c
= ' ', it
->len
= 1;
6293 CHARPOS (position
) = BYTEPOS (position
) = -1;
6295 else if (STRING_MULTIBYTE (it
->string
))
6297 int maxlen
= SBYTES (it
->string
) - IT_STRING_BYTEPOS (*it
);
6298 const unsigned char *s
= (SDATA (it
->string
)
6299 + IT_STRING_BYTEPOS (*it
));
6300 it
->c
= string_char_and_length (s
, maxlen
, &it
->len
);
6304 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
6309 /* Record what we have and where it came from. */
6310 it
->what
= IT_CHARACTER
;
6311 it
->object
= it
->string
;
6312 it
->position
= position
;
6317 /* Load IT with next display element from C string IT->s.
6318 IT->string_nchars is the maximum number of characters to return
6319 from the string. IT->end_charpos may be greater than
6320 IT->string_nchars when this function is called, in which case we
6321 may have to return padding spaces. Value is zero if end of string
6322 reached, including padding spaces. */
6325 next_element_from_c_string (it
)
6331 it
->what
= IT_CHARACTER
;
6332 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = 0;
6335 /* IT's position can be greater IT->string_nchars in case a field
6336 width or precision has been specified when the iterator was
6338 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
6340 /* End of the game. */
6344 else if (IT_CHARPOS (*it
) >= it
->string_nchars
)
6346 /* Pad with spaces. */
6347 it
->c
= ' ', it
->len
= 1;
6348 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = -1;
6350 else if (it
->multibyte_p
)
6352 /* Implementation note: The calls to strlen apparently aren't a
6353 performance problem because there is no noticeable performance
6354 difference between Emacs running in unibyte or multibyte mode. */
6355 int maxlen
= strlen (it
->s
) - IT_BYTEPOS (*it
);
6356 it
->c
= string_char_and_length (it
->s
+ IT_BYTEPOS (*it
),
6360 it
->c
= it
->s
[IT_BYTEPOS (*it
)], it
->len
= 1;
6366 /* Set up IT to return characters from an ellipsis, if appropriate.
6367 The definition of the ellipsis glyphs may come from a display table
6368 entry. This function Fills IT with the first glyph from the
6369 ellipsis if an ellipsis is to be displayed. */
6372 next_element_from_ellipsis (it
)
6375 if (it
->selective_display_ellipsis_p
)
6376 setup_for_ellipsis (it
, it
->len
);
6379 /* The face at the current position may be different from the
6380 face we find after the invisible text. Remember what it
6381 was in IT->saved_face_id, and signal that it's there by
6382 setting face_before_selective_p. */
6383 it
->saved_face_id
= it
->face_id
;
6384 it
->method
= GET_FROM_BUFFER
;
6385 it
->object
= it
->w
->buffer
;
6386 reseat_at_next_visible_line_start (it
, 1);
6387 it
->face_before_selective_p
= 1;
6390 return get_next_display_element (it
);
6394 /* Deliver an image display element. The iterator IT is already
6395 filled with image information (done in handle_display_prop). Value
6400 next_element_from_image (it
)
6403 it
->what
= IT_IMAGE
;
6408 /* Fill iterator IT with next display element from a stretch glyph
6409 property. IT->object is the value of the text property. Value is
6413 next_element_from_stretch (it
)
6416 it
->what
= IT_STRETCH
;
6421 /* Load IT with the next display element from current_buffer. Value
6422 is zero if end of buffer reached. IT->stop_charpos is the next
6423 position at which to stop and check for text properties or buffer
6427 next_element_from_buffer (it
)
6432 /* Check this assumption, otherwise, we would never enter the
6433 if-statement, below. */
6434 xassert (IT_CHARPOS (*it
) >= BEGV
6435 && IT_CHARPOS (*it
) <= it
->stop_charpos
);
6437 if (IT_CHARPOS (*it
) >= it
->stop_charpos
)
6439 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
6441 int overlay_strings_follow_p
;
6443 /* End of the game, except when overlay strings follow that
6444 haven't been returned yet. */
6445 if (it
->overlay_strings_at_end_processed_p
)
6446 overlay_strings_follow_p
= 0;
6449 it
->overlay_strings_at_end_processed_p
= 1;
6450 overlay_strings_follow_p
= get_overlay_strings (it
, 0);
6453 if (overlay_strings_follow_p
)
6454 success_p
= get_next_display_element (it
);
6458 it
->position
= it
->current
.pos
;
6465 return get_next_display_element (it
);
6470 /* No face changes, overlays etc. in sight, so just return a
6471 character from current_buffer. */
6474 /* Maybe run the redisplay end trigger hook. Performance note:
6475 This doesn't seem to cost measurable time. */
6476 if (it
->redisplay_end_trigger_charpos
6478 && IT_CHARPOS (*it
) >= it
->redisplay_end_trigger_charpos
)
6479 run_redisplay_end_trigger_hook (it
);
6481 /* Get the next character, maybe multibyte. */
6482 p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
6483 if (it
->multibyte_p
&& !ASCII_BYTE_P (*p
))
6485 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT_BYTE
? ZV_BYTE
: GPT_BYTE
)
6486 - IT_BYTEPOS (*it
));
6487 it
->c
= string_char_and_length (p
, maxlen
, &it
->len
);
6490 it
->c
= *p
, it
->len
= 1;
6492 /* Record what we have and where it came from. */
6493 it
->what
= IT_CHARACTER
;
6494 it
->object
= it
->w
->buffer
;
6495 it
->position
= it
->current
.pos
;
6497 /* Normally we return the character found above, except when we
6498 really want to return an ellipsis for selective display. */
6503 /* A value of selective > 0 means hide lines indented more
6504 than that number of columns. */
6505 if (it
->selective
> 0
6506 && IT_CHARPOS (*it
) + 1 < ZV
6507 && indented_beyond_p (IT_CHARPOS (*it
) + 1,
6508 IT_BYTEPOS (*it
) + 1,
6509 (double) it
->selective
)) /* iftc */
6511 success_p
= next_element_from_ellipsis (it
);
6512 it
->dpvec_char_len
= -1;
6515 else if (it
->c
== '\r' && it
->selective
== -1)
6517 /* A value of selective == -1 means that everything from the
6518 CR to the end of the line is invisible, with maybe an
6519 ellipsis displayed for it. */
6520 success_p
= next_element_from_ellipsis (it
);
6521 it
->dpvec_char_len
= -1;
6526 /* Value is zero if end of buffer reached. */
6527 xassert (!success_p
|| it
->what
!= IT_CHARACTER
|| it
->len
> 0);
6532 /* Run the redisplay end trigger hook for IT. */
6535 run_redisplay_end_trigger_hook (it
)
6538 Lisp_Object args
[3];
6540 /* IT->glyph_row should be non-null, i.e. we should be actually
6541 displaying something, or otherwise we should not run the hook. */
6542 xassert (it
->glyph_row
);
6544 /* Set up hook arguments. */
6545 args
[0] = Qredisplay_end_trigger_functions
;
6546 args
[1] = it
->window
;
6547 XSETINT (args
[2], it
->redisplay_end_trigger_charpos
);
6548 it
->redisplay_end_trigger_charpos
= 0;
6550 /* Since we are *trying* to run these functions, don't try to run
6551 them again, even if they get an error. */
6552 it
->w
->redisplay_end_trigger
= Qnil
;
6553 Frun_hook_with_args (3, args
);
6555 /* Notice if it changed the face of the character we are on. */
6556 handle_face_prop (it
);
6560 /* Deliver a composition display element. The iterator IT is already
6561 filled with composition information (done in
6562 handle_composition_prop). Value is always 1. */
6565 next_element_from_composition (it
)
6568 it
->what
= IT_COMPOSITION
;
6569 it
->position
= (STRINGP (it
->string
)
6570 ? it
->current
.string_pos
6572 if (STRINGP (it
->string
))
6573 it
->object
= it
->string
;
6575 it
->object
= it
->w
->buffer
;
6581 /***********************************************************************
6582 Moving an iterator without producing glyphs
6583 ***********************************************************************/
6585 /* Check if iterator is at a position corresponding to a valid buffer
6586 position after some move_it_ call. */
6588 #define IT_POS_VALID_AFTER_MOVE_P(it) \
6589 ((it)->method == GET_FROM_STRING \
6590 ? IT_STRING_CHARPOS (*it) == 0 \
6594 /* Move iterator IT to a specified buffer or X position within one
6595 line on the display without producing glyphs.
6597 OP should be a bit mask including some or all of these bits:
6598 MOVE_TO_X: Stop on reaching x-position TO_X.
6599 MOVE_TO_POS: Stop on reaching buffer or string position TO_CHARPOS.
6600 Regardless of OP's value, stop in reaching the end of the display line.
6602 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
6603 This means, in particular, that TO_X includes window's horizontal
6606 The return value has several possible values that
6607 say what condition caused the scan to stop:
6609 MOVE_POS_MATCH_OR_ZV
6610 - when TO_POS or ZV was reached.
6613 -when TO_X was reached before TO_POS or ZV were reached.
6616 - when we reached the end of the display area and the line must
6620 - when we reached the end of the display area and the line is
6624 - when we stopped at a line end, i.e. a newline or a CR and selective
6627 static enum move_it_result
6628 move_it_in_display_line_to (it
, to_charpos
, to_x
, op
)
6630 int to_charpos
, to_x
, op
;
6632 enum move_it_result result
= MOVE_UNDEFINED
;
6633 struct glyph_row
*saved_glyph_row
;
6635 /* Don't produce glyphs in produce_glyphs. */
6636 saved_glyph_row
= it
->glyph_row
;
6637 it
->glyph_row
= NULL
;
6639 #define BUFFER_POS_REACHED_P() \
6640 ((op & MOVE_TO_POS) != 0 \
6641 && BUFFERP (it->object) \
6642 && IT_CHARPOS (*it) >= to_charpos \
6643 && (it->method == GET_FROM_BUFFER \
6644 || (it->method == GET_FROM_DISPLAY_VECTOR \
6645 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
6650 int x
, i
, ascent
= 0, descent
= 0;
6652 /* Stop if we move beyond TO_CHARPOS (after an image or stretch glyph). */
6653 if ((op
& MOVE_TO_POS
) != 0
6654 && BUFFERP (it
->object
)
6655 && it
->method
== GET_FROM_BUFFER
6656 && IT_CHARPOS (*it
) > to_charpos
)
6658 result
= MOVE_POS_MATCH_OR_ZV
;
6662 /* Stop when ZV reached.
6663 We used to stop here when TO_CHARPOS reached as well, but that is
6664 too soon if this glyph does not fit on this line. So we handle it
6665 explicitly below. */
6666 if (!get_next_display_element (it
)
6667 || (it
->truncate_lines_p
6668 && BUFFER_POS_REACHED_P ()))
6670 result
= MOVE_POS_MATCH_OR_ZV
;
6674 /* The call to produce_glyphs will get the metrics of the
6675 display element IT is loaded with. We record in x the
6676 x-position before this display element in case it does not
6680 /* Remember the line height so far in case the next element doesn't
6682 if (!it
->truncate_lines_p
)
6684 ascent
= it
->max_ascent
;
6685 descent
= it
->max_descent
;
6688 PRODUCE_GLYPHS (it
);
6690 if (it
->area
!= TEXT_AREA
)
6692 set_iterator_to_next (it
, 1);
6696 /* The number of glyphs we get back in IT->nglyphs will normally
6697 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
6698 character on a terminal frame, or (iii) a line end. For the
6699 second case, IT->nglyphs - 1 padding glyphs will be present
6700 (on X frames, there is only one glyph produced for a
6701 composite character.
6703 The behavior implemented below means, for continuation lines,
6704 that as many spaces of a TAB as fit on the current line are
6705 displayed there. For terminal frames, as many glyphs of a
6706 multi-glyph character are displayed in the current line, too.
6707 This is what the old redisplay code did, and we keep it that
6708 way. Under X, the whole shape of a complex character must
6709 fit on the line or it will be completely displayed in the
6712 Note that both for tabs and padding glyphs, all glyphs have
6716 /* More than one glyph or glyph doesn't fit on line. All
6717 glyphs have the same width. */
6718 int single_glyph_width
= it
->pixel_width
/ it
->nglyphs
;
6720 int x_before_this_char
= x
;
6721 int hpos_before_this_char
= it
->hpos
;
6723 for (i
= 0; i
< it
->nglyphs
; ++i
, x
= new_x
)
6725 new_x
= x
+ single_glyph_width
;
6727 /* We want to leave anything reaching TO_X to the caller. */
6728 if ((op
& MOVE_TO_X
) && new_x
> to_x
)
6730 if (BUFFER_POS_REACHED_P ())
6731 goto buffer_pos_reached
;
6733 result
= MOVE_X_REACHED
;
6736 else if (/* Lines are continued. */
6737 !it
->truncate_lines_p
6738 && (/* And glyph doesn't fit on the line. */
6739 new_x
> it
->last_visible_x
6740 /* Or it fits exactly and we're on a window
6742 || (new_x
== it
->last_visible_x
6743 && FRAME_WINDOW_P (it
->f
))))
6745 if (/* IT->hpos == 0 means the very first glyph
6746 doesn't fit on the line, e.g. a wide image. */
6748 || (new_x
== it
->last_visible_x
6749 && FRAME_WINDOW_P (it
->f
)))
6752 it
->current_x
= new_x
;
6754 /* The character's last glyph just barely fits
6756 if (i
== it
->nglyphs
- 1)
6758 /* If this is the destination position,
6759 return a position *before* it in this row,
6760 now that we know it fits in this row. */
6761 if (BUFFER_POS_REACHED_P ())
6763 it
->hpos
= hpos_before_this_char
;
6764 it
->current_x
= x_before_this_char
;
6765 result
= MOVE_POS_MATCH_OR_ZV
;
6769 set_iterator_to_next (it
, 1);
6770 #ifdef HAVE_WINDOW_SYSTEM
6771 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
6773 if (!get_next_display_element (it
))
6775 result
= MOVE_POS_MATCH_OR_ZV
;
6778 if (BUFFER_POS_REACHED_P ())
6780 if (ITERATOR_AT_END_OF_LINE_P (it
))
6781 result
= MOVE_POS_MATCH_OR_ZV
;
6783 result
= MOVE_LINE_CONTINUED
;
6786 if (ITERATOR_AT_END_OF_LINE_P (it
))
6788 result
= MOVE_NEWLINE_OR_CR
;
6792 #endif /* HAVE_WINDOW_SYSTEM */
6798 it
->max_ascent
= ascent
;
6799 it
->max_descent
= descent
;
6802 TRACE_MOVE ((stderr
, "move_it_in: continued at %d\n",
6804 result
= MOVE_LINE_CONTINUED
;
6807 else if (BUFFER_POS_REACHED_P ())
6808 goto buffer_pos_reached
;
6809 else if (new_x
> it
->first_visible_x
)
6811 /* Glyph is visible. Increment number of glyphs that
6812 would be displayed. */
6817 /* Glyph is completely off the left margin of the display
6818 area. Nothing to do. */
6822 if (result
!= MOVE_UNDEFINED
)
6825 else if (BUFFER_POS_REACHED_P ())
6829 it
->max_ascent
= ascent
;
6830 it
->max_descent
= descent
;
6831 result
= MOVE_POS_MATCH_OR_ZV
;
6834 else if ((op
& MOVE_TO_X
) && it
->current_x
>= to_x
)
6836 /* Stop when TO_X specified and reached. This check is
6837 necessary here because of lines consisting of a line end,
6838 only. The line end will not produce any glyphs and we
6839 would never get MOVE_X_REACHED. */
6840 xassert (it
->nglyphs
== 0);
6841 result
= MOVE_X_REACHED
;
6845 /* Is this a line end? If yes, we're done. */
6846 if (ITERATOR_AT_END_OF_LINE_P (it
))
6848 result
= MOVE_NEWLINE_OR_CR
;
6852 /* The current display element has been consumed. Advance
6854 set_iterator_to_next (it
, 1);
6856 /* Stop if lines are truncated and IT's current x-position is
6857 past the right edge of the window now. */
6858 if (it
->truncate_lines_p
6859 && it
->current_x
>= it
->last_visible_x
)
6861 #ifdef HAVE_WINDOW_SYSTEM
6862 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
6864 if (!get_next_display_element (it
)
6865 || BUFFER_POS_REACHED_P ())
6867 result
= MOVE_POS_MATCH_OR_ZV
;
6870 if (ITERATOR_AT_END_OF_LINE_P (it
))
6872 result
= MOVE_NEWLINE_OR_CR
;
6876 #endif /* HAVE_WINDOW_SYSTEM */
6877 result
= MOVE_LINE_TRUNCATED
;
6882 #undef BUFFER_POS_REACHED_P
6884 /* Restore the iterator settings altered at the beginning of this
6886 it
->glyph_row
= saved_glyph_row
;
6891 /* Move IT forward until it satisfies one or more of the criteria in
6892 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
6894 OP is a bit-mask that specifies where to stop, and in particular,
6895 which of those four position arguments makes a difference. See the
6896 description of enum move_operation_enum.
6898 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
6899 screen line, this function will set IT to the next position >
6903 move_it_to (it
, to_charpos
, to_x
, to_y
, to_vpos
, op
)
6905 int to_charpos
, to_x
, to_y
, to_vpos
;
6908 enum move_it_result skip
, skip2
= MOVE_X_REACHED
;
6914 if (op
& MOVE_TO_VPOS
)
6916 /* If no TO_CHARPOS and no TO_X specified, stop at the
6917 start of the line TO_VPOS. */
6918 if ((op
& (MOVE_TO_X
| MOVE_TO_POS
)) == 0)
6920 if (it
->vpos
== to_vpos
)
6926 skip
= move_it_in_display_line_to (it
, -1, -1, 0);
6930 /* TO_VPOS >= 0 means stop at TO_X in the line at
6931 TO_VPOS, or at TO_POS, whichever comes first. */
6932 if (it
->vpos
== to_vpos
)
6938 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
6940 if (skip
== MOVE_POS_MATCH_OR_ZV
|| it
->vpos
== to_vpos
)
6945 else if (skip
== MOVE_X_REACHED
&& it
->vpos
!= to_vpos
)
6947 /* We have reached TO_X but not in the line we want. */
6948 skip
= move_it_in_display_line_to (it
, to_charpos
,
6950 if (skip
== MOVE_POS_MATCH_OR_ZV
)
6958 else if (op
& MOVE_TO_Y
)
6960 struct it it_backup
;
6962 /* TO_Y specified means stop at TO_X in the line containing
6963 TO_Y---or at TO_CHARPOS if this is reached first. The
6964 problem is that we can't really tell whether the line
6965 contains TO_Y before we have completely scanned it, and
6966 this may skip past TO_X. What we do is to first scan to
6969 If TO_X is not specified, use a TO_X of zero. The reason
6970 is to make the outcome of this function more predictable.
6971 If we didn't use TO_X == 0, we would stop at the end of
6972 the line which is probably not what a caller would expect
6974 skip
= move_it_in_display_line_to (it
, to_charpos
,
6978 | (op
& MOVE_TO_POS
)));
6980 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
6981 if (skip
== MOVE_POS_MATCH_OR_ZV
)
6987 /* If TO_X was reached, we would like to know whether TO_Y
6988 is in the line. This can only be said if we know the
6989 total line height which requires us to scan the rest of
6991 if (skip
== MOVE_X_REACHED
)
6993 /* Wait! We can conclude that TO_Y is in the line if
6994 the already scanned glyphs make the line tall enough
6995 because further scanning doesn't make it shorter. */
6996 line_height
= it
->max_ascent
+ it
->max_descent
;
6997 if (to_y
>= it
->current_y
6998 && to_y
< it
->current_y
+ line_height
)
7004 TRACE_MOVE ((stderr
, "move_it: from %d\n", IT_CHARPOS (*it
)));
7005 skip2
= move_it_in_display_line_to (it
, to_charpos
, -1,
7007 TRACE_MOVE ((stderr
, "move_it: to %d\n", IT_CHARPOS (*it
)));
7010 /* Now, decide whether TO_Y is in this line. */
7011 line_height
= it
->max_ascent
+ it
->max_descent
;
7012 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
7014 if (to_y
>= it
->current_y
7015 && to_y
< it
->current_y
+ line_height
)
7017 if (skip
== MOVE_X_REACHED
)
7018 /* If TO_Y is in this line and TO_X was reached above,
7019 we scanned too far. We have to restore IT's settings
7020 to the ones before skipping. */
7024 else if (skip
== MOVE_X_REACHED
)
7027 if (skip
== MOVE_POS_MATCH_OR_ZV
)
7034 else if (BUFFERP (it
->object
)
7035 && it
->method
== GET_FROM_BUFFER
7036 && IT_CHARPOS (*it
) >= to_charpos
)
7037 skip
= MOVE_POS_MATCH_OR_ZV
;
7039 skip
= move_it_in_display_line_to (it
, to_charpos
, -1, MOVE_TO_POS
);
7043 case MOVE_POS_MATCH_OR_ZV
:
7047 case MOVE_NEWLINE_OR_CR
:
7048 set_iterator_to_next (it
, 1);
7049 it
->continuation_lines_width
= 0;
7052 case MOVE_LINE_TRUNCATED
:
7053 it
->continuation_lines_width
= 0;
7054 reseat_at_next_visible_line_start (it
, 0);
7055 if ((op
& MOVE_TO_POS
) != 0
7056 && IT_CHARPOS (*it
) > to_charpos
)
7063 case MOVE_LINE_CONTINUED
:
7064 /* For continued lines ending in a tab, some of the glyphs
7065 associated with the tab are displayed on the current
7066 line. Since it->current_x does not include these glyphs,
7067 we use it->last_visible_x instead. */
7068 it
->continuation_lines_width
+=
7069 (it
->c
== '\t') ? it
->last_visible_x
: it
->current_x
;
7076 /* Reset/increment for the next run. */
7077 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
7078 it
->current_x
= it
->hpos
= 0;
7079 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
7081 last_height
= it
->max_ascent
+ it
->max_descent
;
7082 last_max_ascent
= it
->max_ascent
;
7083 it
->max_ascent
= it
->max_descent
= 0;
7088 TRACE_MOVE ((stderr
, "move_it_to: reached %d\n", reached
));
7092 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
7094 If DY > 0, move IT backward at least that many pixels. DY = 0
7095 means move IT backward to the preceding line start or BEGV. This
7096 function may move over more than DY pixels if IT->current_y - DY
7097 ends up in the middle of a line; in this case IT->current_y will be
7098 set to the top of the line moved to. */
7101 move_it_vertically_backward (it
, dy
)
7112 start_pos
= IT_CHARPOS (*it
);
7114 /* Estimate how many newlines we must move back. */
7115 nlines
= max (1, dy
/ FRAME_LINE_HEIGHT (it
->f
));
7117 /* Set the iterator's position that many lines back. */
7118 while (nlines
-- && IT_CHARPOS (*it
) > BEGV
)
7119 back_to_previous_visible_line_start (it
);
7121 /* Reseat the iterator here. When moving backward, we don't want
7122 reseat to skip forward over invisible text, set up the iterator
7123 to deliver from overlay strings at the new position etc. So,
7124 use reseat_1 here. */
7125 reseat_1 (it
, it
->current
.pos
, 1);
7127 /* We are now surely at a line start. */
7128 it
->current_x
= it
->hpos
= 0;
7129 it
->continuation_lines_width
= 0;
7131 /* Move forward and see what y-distance we moved. First move to the
7132 start of the next line so that we get its height. We need this
7133 height to be able to tell whether we reached the specified
7136 it2
.max_ascent
= it2
.max_descent
= 0;
7139 move_it_to (&it2
, start_pos
, -1, -1, it2
.vpos
+ 1,
7140 MOVE_TO_POS
| MOVE_TO_VPOS
);
7142 while (!IT_POS_VALID_AFTER_MOVE_P (&it2
));
7143 xassert (IT_CHARPOS (*it
) >= BEGV
);
7146 move_it_to (&it2
, start_pos
, -1, -1, -1, MOVE_TO_POS
);
7147 xassert (IT_CHARPOS (*it
) >= BEGV
);
7148 /* H is the actual vertical distance from the position in *IT
7149 and the starting position. */
7150 h
= it2
.current_y
- it
->current_y
;
7151 /* NLINES is the distance in number of lines. */
7152 nlines
= it2
.vpos
- it
->vpos
;
7154 /* Correct IT's y and vpos position
7155 so that they are relative to the starting point. */
7161 /* DY == 0 means move to the start of the screen line. The
7162 value of nlines is > 0 if continuation lines were involved. */
7164 move_it_by_lines (it
, nlines
, 1);
7166 /* I think this assert is bogus if buffer contains
7167 invisible text or images. KFS. */
7168 xassert (IT_CHARPOS (*it
) <= start_pos
);
7173 /* The y-position we try to reach, relative to *IT.
7174 Note that H has been subtracted in front of the if-statement. */
7175 int target_y
= it
->current_y
+ h
- dy
;
7176 int y0
= it3
.current_y
;
7177 int y1
= line_bottom_y (&it3
);
7178 int line_height
= y1
- y0
;
7180 /* If we did not reach target_y, try to move further backward if
7181 we can. If we moved too far backward, try to move forward. */
7182 if (target_y
< it
->current_y
7183 /* This is heuristic. In a window that's 3 lines high, with
7184 a line height of 13 pixels each, recentering with point
7185 on the bottom line will try to move -39/2 = 19 pixels
7186 backward. Try to avoid moving into the first line. */
7187 && (it
->current_y
- target_y
7188 > min (window_box_height (it
->w
), line_height
* 2 / 3))
7189 && IT_CHARPOS (*it
) > BEGV
)
7191 TRACE_MOVE ((stderr
, " not far enough -> move_vert %d\n",
7192 target_y
- it
->current_y
));
7193 dy
= it
->current_y
- target_y
;
7194 goto move_further_back
;
7196 else if (target_y
>= it
->current_y
+ line_height
7197 && IT_CHARPOS (*it
) < ZV
)
7199 /* Should move forward by at least one line, maybe more.
7201 Note: Calling move_it_by_lines can be expensive on
7202 terminal frames, where compute_motion is used (via
7203 vmotion) to do the job, when there are very long lines
7204 and truncate-lines is nil. That's the reason for
7205 treating terminal frames specially here. */
7207 if (!FRAME_WINDOW_P (it
->f
))
7208 move_it_vertically (it
, target_y
- (it
->current_y
+ line_height
));
7213 move_it_by_lines (it
, 1, 1);
7215 while (target_y
>= line_bottom_y (it
) && IT_CHARPOS (*it
) < ZV
);
7219 /* I think this assert is bogus if buffer contains
7220 invisible text or images. KFS. */
7221 xassert (IT_CHARPOS (*it
) >= BEGV
);
7228 /* Move IT by a specified amount of pixel lines DY. DY negative means
7229 move backwards. DY = 0 means move to start of screen line. At the
7230 end, IT will be on the start of a screen line. */
7233 move_it_vertically (it
, dy
)
7238 move_it_vertically_backward (it
, -dy
);
7241 TRACE_MOVE ((stderr
, "move_it_v: from %d, %d\n", IT_CHARPOS (*it
), dy
));
7242 move_it_to (it
, ZV
, -1, it
->current_y
+ dy
, -1,
7243 MOVE_TO_POS
| MOVE_TO_Y
);
7244 TRACE_MOVE ((stderr
, "move_it_v: to %d\n", IT_CHARPOS (*it
)));
7246 /* If buffer ends in ZV without a newline, move to the start of
7247 the line to satisfy the post-condition. */
7248 if (IT_CHARPOS (*it
) == ZV
7250 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
7251 move_it_by_lines (it
, 0, 0);
7256 /* Move iterator IT past the end of the text line it is in. */
7259 move_it_past_eol (it
)
7262 enum move_it_result rc
;
7264 rc
= move_it_in_display_line_to (it
, Z
, 0, MOVE_TO_POS
);
7265 if (rc
== MOVE_NEWLINE_OR_CR
)
7266 set_iterator_to_next (it
, 0);
7270 #if 0 /* Currently not used. */
7272 /* Return non-zero if some text between buffer positions START_CHARPOS
7273 and END_CHARPOS is invisible. IT->window is the window for text
7277 invisible_text_between_p (it
, start_charpos
, end_charpos
)
7279 int start_charpos
, end_charpos
;
7281 Lisp_Object prop
, limit
;
7282 int invisible_found_p
;
7284 xassert (it
!= NULL
&& start_charpos
<= end_charpos
);
7286 /* Is text at START invisible? */
7287 prop
= Fget_char_property (make_number (start_charpos
), Qinvisible
,
7289 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
7290 invisible_found_p
= 1;
7293 limit
= Fnext_single_char_property_change (make_number (start_charpos
),
7295 make_number (end_charpos
));
7296 invisible_found_p
= XFASTINT (limit
) < end_charpos
;
7299 return invisible_found_p
;
7305 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
7306 negative means move up. DVPOS == 0 means move to the start of the
7307 screen line. NEED_Y_P non-zero means calculate IT->current_y. If
7308 NEED_Y_P is zero, IT->current_y will be left unchanged.
7310 Further optimization ideas: If we would know that IT->f doesn't use
7311 a face with proportional font, we could be faster for
7312 truncate-lines nil. */
7315 move_it_by_lines (it
, dvpos
, need_y_p
)
7317 int dvpos
, need_y_p
;
7319 struct position pos
;
7321 /* The commented-out optimization uses vmotion on terminals. This
7322 gives bad results, because elements like it->what, on which
7323 callers such as pos_visible_p rely, aren't updated. */
7324 /* if (!FRAME_WINDOW_P (it->f))
7326 struct text_pos textpos;
7328 pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
7329 SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
7330 reseat (it, textpos, 1);
7331 it->vpos += pos.vpos;
7332 it->current_y += pos.vpos;
7338 /* DVPOS == 0 means move to the start of the screen line. */
7339 move_it_vertically_backward (it
, 0);
7340 xassert (it
->current_x
== 0 && it
->hpos
== 0);
7341 /* Let next call to line_bottom_y calculate real line height */
7346 move_it_to (it
, -1, -1, -1, it
->vpos
+ dvpos
, MOVE_TO_VPOS
);
7347 if (!IT_POS_VALID_AFTER_MOVE_P (it
))
7348 move_it_to (it
, IT_CHARPOS (*it
) + 1, -1, -1, -1, MOVE_TO_POS
);
7353 int start_charpos
, i
;
7355 /* Start at the beginning of the screen line containing IT's
7356 position. This may actually move vertically backwards,
7357 in case of overlays, so adjust dvpos accordingly. */
7359 move_it_vertically_backward (it
, 0);
7362 /* Go back -DVPOS visible lines and reseat the iterator there. */
7363 start_charpos
= IT_CHARPOS (*it
);
7364 for (i
= -dvpos
; i
> 0 && IT_CHARPOS (*it
) > BEGV
; --i
)
7365 back_to_previous_visible_line_start (it
);
7366 reseat (it
, it
->current
.pos
, 1);
7368 /* Move further back if we end up in a string or an image. */
7369 while (!IT_POS_VALID_AFTER_MOVE_P (it
))
7371 /* First try to move to start of display line. */
7373 move_it_vertically_backward (it
, 0);
7375 if (IT_POS_VALID_AFTER_MOVE_P (it
))
7377 /* If start of line is still in string or image,
7378 move further back. */
7379 back_to_previous_visible_line_start (it
);
7380 reseat (it
, it
->current
.pos
, 1);
7384 it
->current_x
= it
->hpos
= 0;
7386 /* Above call may have moved too far if continuation lines
7387 are involved. Scan forward and see if it did. */
7389 it2
.vpos
= it2
.current_y
= 0;
7390 move_it_to (&it2
, start_charpos
, -1, -1, -1, MOVE_TO_POS
);
7391 it
->vpos
-= it2
.vpos
;
7392 it
->current_y
-= it2
.current_y
;
7393 it
->current_x
= it
->hpos
= 0;
7395 /* If we moved too far back, move IT some lines forward. */
7396 if (it2
.vpos
> -dvpos
)
7398 int delta
= it2
.vpos
+ dvpos
;
7400 move_it_to (it
, -1, -1, -1, it
->vpos
+ delta
, MOVE_TO_VPOS
);
7401 /* Move back again if we got too far ahead. */
7402 if (IT_CHARPOS (*it
) >= start_charpos
)
7408 /* Return 1 if IT points into the middle of a display vector. */
7411 in_display_vector_p (it
)
7414 return (it
->method
== GET_FROM_DISPLAY_VECTOR
7415 && it
->current
.dpvec_index
> 0
7416 && it
->dpvec
+ it
->current
.dpvec_index
!= it
->dpend
);
7420 /***********************************************************************
7422 ***********************************************************************/
7425 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
7429 add_to_log (format
, arg1
, arg2
)
7431 Lisp_Object arg1
, arg2
;
7433 Lisp_Object args
[3];
7434 Lisp_Object msg
, fmt
;
7437 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
7440 /* Do nothing if called asynchronously. Inserting text into
7441 a buffer may call after-change-functions and alike and
7442 that would means running Lisp asynchronously. */
7443 if (handling_signal
)
7447 GCPRO4 (fmt
, msg
, arg1
, arg2
);
7449 args
[0] = fmt
= build_string (format
);
7452 msg
= Fformat (3, args
);
7454 len
= SBYTES (msg
) + 1;
7455 SAFE_ALLOCA (buffer
, char *, len
);
7456 bcopy (SDATA (msg
), buffer
, len
);
7458 message_dolog (buffer
, len
- 1, 1, 0);
7465 /* Output a newline in the *Messages* buffer if "needs" one. */
7468 message_log_maybe_newline ()
7470 if (message_log_need_newline
)
7471 message_dolog ("", 0, 1, 0);
7475 /* Add a string M of length NBYTES to the message log, optionally
7476 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
7477 nonzero, means interpret the contents of M as multibyte. This
7478 function calls low-level routines in order to bypass text property
7479 hooks, etc. which might not be safe to run.
7481 This may GC (insert may run before/after change hooks),
7482 so the buffer M must NOT point to a Lisp string. */
7485 message_dolog (m
, nbytes
, nlflag
, multibyte
)
7487 int nbytes
, nlflag
, multibyte
;
7489 if (!NILP (Vmemory_full
))
7492 if (!NILP (Vmessage_log_max
))
7494 struct buffer
*oldbuf
;
7495 Lisp_Object oldpoint
, oldbegv
, oldzv
;
7496 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
7497 int point_at_end
= 0;
7499 Lisp_Object old_deactivate_mark
, tem
;
7500 struct gcpro gcpro1
;
7502 old_deactivate_mark
= Vdeactivate_mark
;
7503 oldbuf
= current_buffer
;
7504 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name
));
7505 current_buffer
->undo_list
= Qt
;
7507 oldpoint
= message_dolog_marker1
;
7508 set_marker_restricted (oldpoint
, make_number (PT
), Qnil
);
7509 oldbegv
= message_dolog_marker2
;
7510 set_marker_restricted (oldbegv
, make_number (BEGV
), Qnil
);
7511 oldzv
= message_dolog_marker3
;
7512 set_marker_restricted (oldzv
, make_number (ZV
), Qnil
);
7513 GCPRO1 (old_deactivate_mark
);
7521 BEGV_BYTE
= BEG_BYTE
;
7524 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
7526 /* Insert the string--maybe converting multibyte to single byte
7527 or vice versa, so that all the text fits the buffer. */
7529 && NILP (current_buffer
->enable_multibyte_characters
))
7531 int i
, c
, char_bytes
;
7532 unsigned char work
[1];
7534 /* Convert a multibyte string to single-byte
7535 for the *Message* buffer. */
7536 for (i
= 0; i
< nbytes
; i
+= char_bytes
)
7538 c
= string_char_and_length (m
+ i
, nbytes
- i
, &char_bytes
);
7539 work
[0] = (ASCII_CHAR_P (c
)
7541 : multibyte_char_to_unibyte (c
, Qnil
));
7542 insert_1_both (work
, 1, 1, 1, 0, 0);
7545 else if (! multibyte
7546 && ! NILP (current_buffer
->enable_multibyte_characters
))
7548 int i
, c
, char_bytes
;
7549 unsigned char *msg
= (unsigned char *) m
;
7550 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
7551 /* Convert a single-byte string to multibyte
7552 for the *Message* buffer. */
7553 for (i
= 0; i
< nbytes
; i
++)
7556 c
= unibyte_char_to_multibyte (c
);
7557 char_bytes
= CHAR_STRING (c
, str
);
7558 insert_1_both (str
, 1, char_bytes
, 1, 0, 0);
7562 insert_1 (m
, nbytes
, 1, 0, 0);
7566 int this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
, dup
;
7567 insert_1 ("\n", 1, 1, 0, 0);
7569 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
7571 this_bol_byte
= PT_BYTE
;
7573 /* See if this line duplicates the previous one.
7574 If so, combine duplicates. */
7577 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
7579 prev_bol_byte
= PT_BYTE
;
7581 dup
= message_log_check_duplicate (prev_bol
, prev_bol_byte
,
7582 this_bol
, this_bol_byte
);
7585 del_range_both (prev_bol
, prev_bol_byte
,
7586 this_bol
, this_bol_byte
, 0);
7592 /* If you change this format, don't forget to also
7593 change message_log_check_duplicate. */
7594 sprintf (dupstr
, " [%d times]", dup
);
7595 duplen
= strlen (dupstr
);
7596 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
7597 insert_1 (dupstr
, duplen
, 1, 0, 1);
7602 /* If we have more than the desired maximum number of lines
7603 in the *Messages* buffer now, delete the oldest ones.
7604 This is safe because we don't have undo in this buffer. */
7606 if (NATNUMP (Vmessage_log_max
))
7608 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
7609 -XFASTINT (Vmessage_log_max
) - 1, 0);
7610 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
7613 BEGV
= XMARKER (oldbegv
)->charpos
;
7614 BEGV_BYTE
= marker_byte_position (oldbegv
);
7623 ZV
= XMARKER (oldzv
)->charpos
;
7624 ZV_BYTE
= marker_byte_position (oldzv
);
7628 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
7630 /* We can't do Fgoto_char (oldpoint) because it will run some
7632 TEMP_SET_PT_BOTH (XMARKER (oldpoint
)->charpos
,
7633 XMARKER (oldpoint
)->bytepos
);
7636 unchain_marker (XMARKER (oldpoint
));
7637 unchain_marker (XMARKER (oldbegv
));
7638 unchain_marker (XMARKER (oldzv
));
7640 tem
= Fget_buffer_window (Fcurrent_buffer (), Qt
);
7641 set_buffer_internal (oldbuf
);
7643 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
7644 message_log_need_newline
= !nlflag
;
7645 Vdeactivate_mark
= old_deactivate_mark
;
7650 /* We are at the end of the buffer after just having inserted a newline.
7651 (Note: We depend on the fact we won't be crossing the gap.)
7652 Check to see if the most recent message looks a lot like the previous one.
7653 Return 0 if different, 1 if the new one should just replace it, or a
7654 value N > 1 if we should also append " [N times]". */
7657 message_log_check_duplicate (prev_bol
, prev_bol_byte
, this_bol
, this_bol_byte
)
7658 int prev_bol
, this_bol
;
7659 int prev_bol_byte
, this_bol_byte
;
7662 int len
= Z_BYTE
- 1 - this_bol_byte
;
7664 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
7665 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
7667 for (i
= 0; i
< len
; i
++)
7669 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.')
7677 if (*p1
++ == ' ' && *p1
++ == '[')
7680 while (*p1
>= '0' && *p1
<= '9')
7681 n
= n
* 10 + *p1
++ - '0';
7682 if (strncmp (p1
, " times]\n", 8) == 0)
7689 /* Display an echo area message M with a specified length of NBYTES
7690 bytes. The string may include null characters. If M is 0, clear
7691 out any existing message, and let the mini-buffer text show
7694 This may GC, so the buffer M must NOT point to a Lisp string. */
7697 message2 (m
, nbytes
, multibyte
)
7702 /* First flush out any partial line written with print. */
7703 message_log_maybe_newline ();
7705 message_dolog (m
, nbytes
, 1, multibyte
);
7706 message2_nolog (m
, nbytes
, multibyte
);
7710 /* The non-logging counterpart of message2. */
7713 message2_nolog (m
, nbytes
, multibyte
)
7715 int nbytes
, multibyte
;
7717 struct frame
*sf
= SELECTED_FRAME ();
7718 message_enable_multibyte
= multibyte
;
7722 if (noninteractive_need_newline
)
7723 putc ('\n', stderr
);
7724 noninteractive_need_newline
= 0;
7726 fwrite (m
, nbytes
, 1, stderr
);
7727 if (cursor_in_echo_area
== 0)
7728 fprintf (stderr
, "\n");
7731 /* A null message buffer means that the frame hasn't really been
7732 initialized yet. Error messages get reported properly by
7733 cmd_error, so this must be just an informative message; toss it. */
7734 else if (INTERACTIVE
7735 && sf
->glyphs_initialized_p
7736 && FRAME_MESSAGE_BUF (sf
))
7738 Lisp_Object mini_window
;
7741 /* Get the frame containing the mini-buffer
7742 that the selected frame is using. */
7743 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
7744 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
7746 FRAME_SAMPLE_VISIBILITY (f
);
7747 if (FRAME_VISIBLE_P (sf
)
7748 && ! FRAME_VISIBLE_P (f
))
7749 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
7753 set_message (m
, Qnil
, nbytes
, multibyte
);
7754 if (minibuffer_auto_raise
)
7755 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
7758 clear_message (1, 1);
7760 do_pending_window_change (0);
7761 echo_area_display (1);
7762 do_pending_window_change (0);
7763 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
7764 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
7769 /* Display an echo area message M with a specified length of NBYTES
7770 bytes. The string may include null characters. If M is not a
7771 string, clear out any existing message, and let the mini-buffer
7774 This function cancels echoing. */
7777 message3 (m
, nbytes
, multibyte
)
7782 struct gcpro gcpro1
;
7785 clear_message (1,1);
7788 /* First flush out any partial line written with print. */
7789 message_log_maybe_newline ();
7795 SAFE_ALLOCA (buffer
, char *, nbytes
);
7796 bcopy (SDATA (m
), buffer
, nbytes
);
7797 message_dolog (buffer
, nbytes
, 1, multibyte
);
7800 message3_nolog (m
, nbytes
, multibyte
);
7806 /* The non-logging version of message3.
7807 This does not cancel echoing, because it is used for echoing.
7808 Perhaps we need to make a separate function for echoing
7809 and make this cancel echoing. */
7812 message3_nolog (m
, nbytes
, multibyte
)
7814 int nbytes
, multibyte
;
7816 struct frame
*sf
= SELECTED_FRAME ();
7817 message_enable_multibyte
= multibyte
;
7821 if (noninteractive_need_newline
)
7822 putc ('\n', stderr
);
7823 noninteractive_need_newline
= 0;
7825 fwrite (SDATA (m
), nbytes
, 1, stderr
);
7826 if (cursor_in_echo_area
== 0)
7827 fprintf (stderr
, "\n");
7830 /* A null message buffer means that the frame hasn't really been
7831 initialized yet. Error messages get reported properly by
7832 cmd_error, so this must be just an informative message; toss it. */
7833 else if (INTERACTIVE
7834 && sf
->glyphs_initialized_p
7835 && FRAME_MESSAGE_BUF (sf
))
7837 Lisp_Object mini_window
;
7841 /* Get the frame containing the mini-buffer
7842 that the selected frame is using. */
7843 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
7844 frame
= XWINDOW (mini_window
)->frame
;
7847 FRAME_SAMPLE_VISIBILITY (f
);
7848 if (FRAME_VISIBLE_P (sf
)
7849 && !FRAME_VISIBLE_P (f
))
7850 Fmake_frame_visible (frame
);
7852 if (STRINGP (m
) && SCHARS (m
) > 0)
7854 set_message (NULL
, m
, nbytes
, multibyte
);
7855 if (minibuffer_auto_raise
)
7856 Fraise_frame (frame
);
7857 /* Assume we are not echoing.
7858 (If we are, echo_now will override this.) */
7859 echo_message_buffer
= Qnil
;
7862 clear_message (1, 1);
7864 do_pending_window_change (0);
7865 echo_area_display (1);
7866 do_pending_window_change (0);
7867 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
7868 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
7873 /* Display a null-terminated echo area message M. If M is 0, clear
7874 out any existing message, and let the mini-buffer text show through.
7876 The buffer M must continue to exist until after the echo area gets
7877 cleared or some other message gets displayed there. Do not pass
7878 text that is stored in a Lisp string. Do not pass text in a buffer
7879 that was alloca'd. */
7885 message2 (m
, (m
? strlen (m
) : 0), 0);
7889 /* The non-logging counterpart of message1. */
7895 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
7898 /* Display a message M which contains a single %s
7899 which gets replaced with STRING. */
7902 message_with_string (m
, string
, log
)
7907 CHECK_STRING (string
);
7913 if (noninteractive_need_newline
)
7914 putc ('\n', stderr
);
7915 noninteractive_need_newline
= 0;
7916 fprintf (stderr
, m
, SDATA (string
));
7917 if (cursor_in_echo_area
== 0)
7918 fprintf (stderr
, "\n");
7922 else if (INTERACTIVE
)
7924 /* The frame whose minibuffer we're going to display the message on.
7925 It may be larger than the selected frame, so we need
7926 to use its buffer, not the selected frame's buffer. */
7927 Lisp_Object mini_window
;
7928 struct frame
*f
, *sf
= SELECTED_FRAME ();
7930 /* Get the frame containing the minibuffer
7931 that the selected frame is using. */
7932 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
7933 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
7935 /* A null message buffer means that the frame hasn't really been
7936 initialized yet. Error messages get reported properly by
7937 cmd_error, so this must be just an informative message; toss it. */
7938 if (FRAME_MESSAGE_BUF (f
))
7940 Lisp_Object args
[2], message
;
7941 struct gcpro gcpro1
, gcpro2
;
7943 args
[0] = build_string (m
);
7944 args
[1] = message
= string
;
7945 GCPRO2 (args
[0], message
);
7948 message
= Fformat (2, args
);
7951 message3 (message
, SBYTES (message
), STRING_MULTIBYTE (message
));
7953 message3_nolog (message
, SBYTES (message
), STRING_MULTIBYTE (message
));
7957 /* Print should start at the beginning of the message
7958 buffer next time. */
7959 message_buf_print
= 0;
7965 /* Dump an informative message to the minibuf. If M is 0, clear out
7966 any existing message, and let the mini-buffer text show through. */
7970 message (m
, a1
, a2
, a3
)
7972 EMACS_INT a1
, a2
, a3
;
7978 if (noninteractive_need_newline
)
7979 putc ('\n', stderr
);
7980 noninteractive_need_newline
= 0;
7981 fprintf (stderr
, m
, a1
, a2
, a3
);
7982 if (cursor_in_echo_area
== 0)
7983 fprintf (stderr
, "\n");
7987 else if (INTERACTIVE
)
7989 /* The frame whose mini-buffer we're going to display the message
7990 on. It may be larger than the selected frame, so we need to
7991 use its buffer, not the selected frame's buffer. */
7992 Lisp_Object mini_window
;
7993 struct frame
*f
, *sf
= SELECTED_FRAME ();
7995 /* Get the frame containing the mini-buffer
7996 that the selected frame is using. */
7997 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
7998 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
8000 /* A null message buffer means that the frame hasn't really been
8001 initialized yet. Error messages get reported properly by
8002 cmd_error, so this must be just an informative message; toss
8004 if (FRAME_MESSAGE_BUF (f
))
8015 len
= doprnt (FRAME_MESSAGE_BUF (f
),
8016 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
8018 len
= doprnt (FRAME_MESSAGE_BUF (f
),
8019 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3,
8021 #endif /* NO_ARG_ARRAY */
8023 message2 (FRAME_MESSAGE_BUF (f
), len
, 0);
8028 /* Print should start at the beginning of the message
8029 buffer next time. */
8030 message_buf_print
= 0;
8036 /* The non-logging version of message. */
8039 message_nolog (m
, a1
, a2
, a3
)
8041 EMACS_INT a1
, a2
, a3
;
8043 Lisp_Object old_log_max
;
8044 old_log_max
= Vmessage_log_max
;
8045 Vmessage_log_max
= Qnil
;
8046 message (m
, a1
, a2
, a3
);
8047 Vmessage_log_max
= old_log_max
;
8051 /* Display the current message in the current mini-buffer. This is
8052 only called from error handlers in process.c, and is not time
8058 if (!NILP (echo_area_buffer
[0]))
8061 string
= Fcurrent_message ();
8062 message3 (string
, SBYTES (string
),
8063 !NILP (current_buffer
->enable_multibyte_characters
));
8068 /* Make sure echo area buffers in `echo_buffers' are live.
8069 If they aren't, make new ones. */
8072 ensure_echo_area_buffers ()
8076 for (i
= 0; i
< 2; ++i
)
8077 if (!BUFFERP (echo_buffer
[i
])
8078 || NILP (XBUFFER (echo_buffer
[i
])->name
))
8081 Lisp_Object old_buffer
;
8084 old_buffer
= echo_buffer
[i
];
8085 sprintf (name
, " *Echo Area %d*", i
);
8086 echo_buffer
[i
] = Fget_buffer_create (build_string (name
));
8087 XBUFFER (echo_buffer
[i
])->truncate_lines
= Qnil
;
8089 for (j
= 0; j
< 2; ++j
)
8090 if (EQ (old_buffer
, echo_area_buffer
[j
]))
8091 echo_area_buffer
[j
] = echo_buffer
[i
];
8096 /* Call FN with args A1..A4 with either the current or last displayed
8097 echo_area_buffer as current buffer.
8099 WHICH zero means use the current message buffer
8100 echo_area_buffer[0]. If that is nil, choose a suitable buffer
8101 from echo_buffer[] and clear it.
8103 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
8104 suitable buffer from echo_buffer[] and clear it.
8106 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
8107 that the current message becomes the last displayed one, make
8108 choose a suitable buffer for echo_area_buffer[0], and clear it.
8110 Value is what FN returns. */
8113 with_echo_area_buffer (w
, which
, fn
, a1
, a2
, a3
, a4
)
8116 int (*fn
) P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
8122 int this_one
, the_other
, clear_buffer_p
, rc
;
8123 int count
= SPECPDL_INDEX ();
8125 /* If buffers aren't live, make new ones. */
8126 ensure_echo_area_buffers ();
8131 this_one
= 0, the_other
= 1;
8133 this_one
= 1, the_other
= 0;
8136 this_one
= 0, the_other
= 1;
8139 /* We need a fresh one in case the current echo buffer equals
8140 the one containing the last displayed echo area message. */
8141 if (!NILP (echo_area_buffer
[this_one
])
8142 && EQ (echo_area_buffer
[this_one
], echo_area_buffer
[the_other
]))
8143 echo_area_buffer
[this_one
] = Qnil
;
8146 /* Choose a suitable buffer from echo_buffer[] is we don't
8148 if (NILP (echo_area_buffer
[this_one
]))
8150 echo_area_buffer
[this_one
]
8151 = (EQ (echo_area_buffer
[the_other
], echo_buffer
[this_one
])
8152 ? echo_buffer
[the_other
]
8153 : echo_buffer
[this_one
]);
8157 buffer
= echo_area_buffer
[this_one
];
8159 /* Don't get confused by reusing the buffer used for echoing
8160 for a different purpose. */
8161 if (echo_kboard
== NULL
&& EQ (buffer
, echo_message_buffer
))
8164 record_unwind_protect (unwind_with_echo_area_buffer
,
8165 with_echo_area_buffer_unwind_data (w
));
8167 /* Make the echo area buffer current. Note that for display
8168 purposes, it is not necessary that the displayed window's buffer
8169 == current_buffer, except for text property lookup. So, let's
8170 only set that buffer temporarily here without doing a full
8171 Fset_window_buffer. We must also change w->pointm, though,
8172 because otherwise an assertions in unshow_buffer fails, and Emacs
8174 set_buffer_internal_1 (XBUFFER (buffer
));
8178 set_marker_both (w
->pointm
, buffer
, BEG
, BEG_BYTE
);
8181 current_buffer
->undo_list
= Qt
;
8182 current_buffer
->read_only
= Qnil
;
8183 specbind (Qinhibit_read_only
, Qt
);
8184 specbind (Qinhibit_modification_hooks
, Qt
);
8186 if (clear_buffer_p
&& Z
> BEG
)
8189 xassert (BEGV
>= BEG
);
8190 xassert (ZV
<= Z
&& ZV
>= BEGV
);
8192 rc
= fn (a1
, a2
, a3
, a4
);
8194 xassert (BEGV
>= BEG
);
8195 xassert (ZV
<= Z
&& ZV
>= BEGV
);
8197 unbind_to (count
, Qnil
);
8202 /* Save state that should be preserved around the call to the function
8203 FN called in with_echo_area_buffer. */
8206 with_echo_area_buffer_unwind_data (w
)
8212 /* Reduce consing by keeping one vector in
8213 Vwith_echo_area_save_vector. */
8214 vector
= Vwith_echo_area_save_vector
;
8215 Vwith_echo_area_save_vector
= Qnil
;
8218 vector
= Fmake_vector (make_number (7), Qnil
);
8220 XSETBUFFER (AREF (vector
, i
), current_buffer
); ++i
;
8221 AREF (vector
, i
) = Vdeactivate_mark
, ++i
;
8222 AREF (vector
, i
) = make_number (windows_or_buffers_changed
), ++i
;
8226 XSETWINDOW (AREF (vector
, i
), w
); ++i
;
8227 AREF (vector
, i
) = w
->buffer
; ++i
;
8228 AREF (vector
, i
) = make_number (XMARKER (w
->pointm
)->charpos
); ++i
;
8229 AREF (vector
, i
) = make_number (XMARKER (w
->pointm
)->bytepos
); ++i
;
8234 for (; i
< end
; ++i
)
8235 AREF (vector
, i
) = Qnil
;
8238 xassert (i
== ASIZE (vector
));
8243 /* Restore global state from VECTOR which was created by
8244 with_echo_area_buffer_unwind_data. */
8247 unwind_with_echo_area_buffer (vector
)
8250 set_buffer_internal_1 (XBUFFER (AREF (vector
, 0)));
8251 Vdeactivate_mark
= AREF (vector
, 1);
8252 windows_or_buffers_changed
= XFASTINT (AREF (vector
, 2));
8254 if (WINDOWP (AREF (vector
, 3)))
8257 Lisp_Object buffer
, charpos
, bytepos
;
8259 w
= XWINDOW (AREF (vector
, 3));
8260 buffer
= AREF (vector
, 4);
8261 charpos
= AREF (vector
, 5);
8262 bytepos
= AREF (vector
, 6);
8265 set_marker_both (w
->pointm
, buffer
,
8266 XFASTINT (charpos
), XFASTINT (bytepos
));
8269 Vwith_echo_area_save_vector
= vector
;
8274 /* Set up the echo area for use by print functions. MULTIBYTE_P
8275 non-zero means we will print multibyte. */
8278 setup_echo_area_for_printing (multibyte_p
)
8281 /* If we can't find an echo area any more, exit. */
8282 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8285 ensure_echo_area_buffers ();
8287 if (!message_buf_print
)
8289 /* A message has been output since the last time we printed.
8290 Choose a fresh echo area buffer. */
8291 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
8292 echo_area_buffer
[0] = echo_buffer
[1];
8294 echo_area_buffer
[0] = echo_buffer
[0];
8296 /* Switch to that buffer and clear it. */
8297 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
8298 current_buffer
->truncate_lines
= Qnil
;
8302 int count
= SPECPDL_INDEX ();
8303 specbind (Qinhibit_read_only
, Qt
);
8304 /* Note that undo recording is always disabled. */
8306 unbind_to (count
, Qnil
);
8308 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
8310 /* Set up the buffer for the multibyteness we need. */
8312 != !NILP (current_buffer
->enable_multibyte_characters
))
8313 Fset_buffer_multibyte (multibyte_p
? Qt
: Qnil
);
8315 /* Raise the frame containing the echo area. */
8316 if (minibuffer_auto_raise
)
8318 struct frame
*sf
= SELECTED_FRAME ();
8319 Lisp_Object mini_window
;
8320 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8321 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
8324 message_log_maybe_newline ();
8325 message_buf_print
= 1;
8329 if (NILP (echo_area_buffer
[0]))
8331 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
8332 echo_area_buffer
[0] = echo_buffer
[1];
8334 echo_area_buffer
[0] = echo_buffer
[0];
8337 if (current_buffer
!= XBUFFER (echo_area_buffer
[0]))
8339 /* Someone switched buffers between print requests. */
8340 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
8341 current_buffer
->truncate_lines
= Qnil
;
8347 /* Display an echo area message in window W. Value is non-zero if W's
8348 height is changed. If display_last_displayed_message_p is
8349 non-zero, display the message that was last displayed, otherwise
8350 display the current message. */
8353 display_echo_area (w
)
8356 int i
, no_message_p
, window_height_changed_p
, count
;
8358 /* Temporarily disable garbage collections while displaying the echo
8359 area. This is done because a GC can print a message itself.
8360 That message would modify the echo area buffer's contents while a
8361 redisplay of the buffer is going on, and seriously confuse
8363 count
= inhibit_garbage_collection ();
8365 /* If there is no message, we must call display_echo_area_1
8366 nevertheless because it resizes the window. But we will have to
8367 reset the echo_area_buffer in question to nil at the end because
8368 with_echo_area_buffer will sets it to an empty buffer. */
8369 i
= display_last_displayed_message_p
? 1 : 0;
8370 no_message_p
= NILP (echo_area_buffer
[i
]);
8372 window_height_changed_p
8373 = with_echo_area_buffer (w
, display_last_displayed_message_p
,
8374 display_echo_area_1
,
8375 (EMACS_INT
) w
, Qnil
, 0, 0);
8378 echo_area_buffer
[i
] = Qnil
;
8380 unbind_to (count
, Qnil
);
8381 return window_height_changed_p
;
8385 /* Helper for display_echo_area. Display the current buffer which
8386 contains the current echo area message in window W, a mini-window,
8387 a pointer to which is passed in A1. A2..A4 are currently not used.
8388 Change the height of W so that all of the message is displayed.
8389 Value is non-zero if height of W was changed. */
8392 display_echo_area_1 (a1
, a2
, a3
, a4
)
8397 struct window
*w
= (struct window
*) a1
;
8399 struct text_pos start
;
8400 int window_height_changed_p
= 0;
8402 /* Do this before displaying, so that we have a large enough glyph
8403 matrix for the display. If we can't get enough space for the
8404 whole text, display the last N lines. That works by setting w->start. */
8405 window_height_changed_p
= resize_mini_window (w
, 0);
8407 /* Use the starting position chosen by resize_mini_window. */
8408 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
8411 clear_glyph_matrix (w
->desired_matrix
);
8412 XSETWINDOW (window
, w
);
8413 try_window (window
, start
, 0);
8415 return window_height_changed_p
;
8419 /* Resize the echo area window to exactly the size needed for the
8420 currently displayed message, if there is one. If a mini-buffer
8421 is active, don't shrink it. */
8424 resize_echo_area_exactly ()
8426 if (BUFFERP (echo_area_buffer
[0])
8427 && WINDOWP (echo_area_window
))
8429 struct window
*w
= XWINDOW (echo_area_window
);
8431 Lisp_Object resize_exactly
;
8433 if (minibuf_level
== 0)
8434 resize_exactly
= Qt
;
8436 resize_exactly
= Qnil
;
8438 resized_p
= with_echo_area_buffer (w
, 0, resize_mini_window_1
,
8439 (EMACS_INT
) w
, resize_exactly
, 0, 0);
8442 ++windows_or_buffers_changed
;
8443 ++update_mode_lines
;
8444 redisplay_internal (0);
8450 /* Callback function for with_echo_area_buffer, when used from
8451 resize_echo_area_exactly. A1 contains a pointer to the window to
8452 resize, EXACTLY non-nil means resize the mini-window exactly to the
8453 size of the text displayed. A3 and A4 are not used. Value is what
8454 resize_mini_window returns. */
8457 resize_mini_window_1 (a1
, exactly
, a3
, a4
)
8459 Lisp_Object exactly
;
8462 return resize_mini_window ((struct window
*) a1
, !NILP (exactly
));
8466 /* Resize mini-window W to fit the size of its contents. EXACT:P
8467 means size the window exactly to the size needed. Otherwise, it's
8468 only enlarged until W's buffer is empty.
8470 Set W->start to the right place to begin display. If the whole
8471 contents fit, start at the beginning. Otherwise, start so as
8472 to make the end of the contents appear. This is particularly
8473 important for y-or-n-p, but seems desirable generally.
8475 Value is non-zero if the window height has been changed. */
8478 resize_mini_window (w
, exact_p
)
8482 struct frame
*f
= XFRAME (w
->frame
);
8483 int window_height_changed_p
= 0;
8485 xassert (MINI_WINDOW_P (w
));
8487 /* By default, start display at the beginning. */
8488 set_marker_both (w
->start
, w
->buffer
,
8489 BUF_BEGV (XBUFFER (w
->buffer
)),
8490 BUF_BEGV_BYTE (XBUFFER (w
->buffer
)));
8492 /* Don't resize windows while redisplaying a window; it would
8493 confuse redisplay functions when the size of the window they are
8494 displaying changes from under them. Such a resizing can happen,
8495 for instance, when which-func prints a long message while
8496 we are running fontification-functions. We're running these
8497 functions with safe_call which binds inhibit-redisplay to t. */
8498 if (!NILP (Vinhibit_redisplay
))
8501 /* Nil means don't try to resize. */
8502 if (NILP (Vresize_mini_windows
)
8503 || (FRAME_X_P (f
) && FRAME_X_OUTPUT (f
) == NULL
))
8506 if (!FRAME_MINIBUF_ONLY_P (f
))
8509 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
8510 int total_height
= WINDOW_TOTAL_LINES (root
) + WINDOW_TOTAL_LINES (w
);
8511 int height
, max_height
;
8512 int unit
= FRAME_LINE_HEIGHT (f
);
8513 struct text_pos start
;
8514 struct buffer
*old_current_buffer
= NULL
;
8516 if (current_buffer
!= XBUFFER (w
->buffer
))
8518 old_current_buffer
= current_buffer
;
8519 set_buffer_internal (XBUFFER (w
->buffer
));
8522 init_iterator (&it
, w
, BEGV
, BEGV_BYTE
, NULL
, DEFAULT_FACE_ID
);
8524 /* Compute the max. number of lines specified by the user. */
8525 if (FLOATP (Vmax_mini_window_height
))
8526 max_height
= XFLOATINT (Vmax_mini_window_height
) * FRAME_LINES (f
);
8527 else if (INTEGERP (Vmax_mini_window_height
))
8528 max_height
= XINT (Vmax_mini_window_height
);
8530 max_height
= total_height
/ 4;
8532 /* Correct that max. height if it's bogus. */
8533 max_height
= max (1, max_height
);
8534 max_height
= min (total_height
, max_height
);
8536 /* Find out the height of the text in the window. */
8537 if (it
.truncate_lines_p
)
8542 move_it_to (&it
, ZV
, -1, -1, -1, MOVE_TO_POS
);
8543 if (it
.max_ascent
== 0 && it
.max_descent
== 0)
8544 height
= it
.current_y
+ last_height
;
8546 height
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
8547 height
-= min (it
.extra_line_spacing
, it
.max_extra_line_spacing
);
8548 height
= (height
+ unit
- 1) / unit
;
8551 /* Compute a suitable window start. */
8552 if (height
> max_height
)
8554 height
= max_height
;
8555 init_iterator (&it
, w
, ZV
, ZV_BYTE
, NULL
, DEFAULT_FACE_ID
);
8556 move_it_vertically_backward (&it
, (height
- 1) * unit
);
8557 start
= it
.current
.pos
;
8560 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
8561 SET_MARKER_FROM_TEXT_POS (w
->start
, start
);
8563 if (EQ (Vresize_mini_windows
, Qgrow_only
))
8565 /* Let it grow only, until we display an empty message, in which
8566 case the window shrinks again. */
8567 if (height
> WINDOW_TOTAL_LINES (w
))
8569 int old_height
= WINDOW_TOTAL_LINES (w
);
8570 freeze_window_starts (f
, 1);
8571 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
8572 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
8574 else if (height
< WINDOW_TOTAL_LINES (w
)
8575 && (exact_p
|| BEGV
== ZV
))
8577 int old_height
= WINDOW_TOTAL_LINES (w
);
8578 freeze_window_starts (f
, 0);
8579 shrink_mini_window (w
);
8580 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
8585 /* Always resize to exact size needed. */
8586 if (height
> WINDOW_TOTAL_LINES (w
))
8588 int old_height
= WINDOW_TOTAL_LINES (w
);
8589 freeze_window_starts (f
, 1);
8590 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
8591 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
8593 else if (height
< WINDOW_TOTAL_LINES (w
))
8595 int old_height
= WINDOW_TOTAL_LINES (w
);
8596 freeze_window_starts (f
, 0);
8597 shrink_mini_window (w
);
8601 freeze_window_starts (f
, 1);
8602 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
8605 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
8609 if (old_current_buffer
)
8610 set_buffer_internal (old_current_buffer
);
8613 return window_height_changed_p
;
8617 /* Value is the current message, a string, or nil if there is no
8625 if (NILP (echo_area_buffer
[0]))
8629 with_echo_area_buffer (0, 0, current_message_1
,
8630 (EMACS_INT
) &msg
, Qnil
, 0, 0);
8632 echo_area_buffer
[0] = Qnil
;
8640 current_message_1 (a1
, a2
, a3
, a4
)
8645 Lisp_Object
*msg
= (Lisp_Object
*) a1
;
8648 *msg
= make_buffer_string (BEG
, Z
, 1);
8655 /* Push the current message on Vmessage_stack for later restauration
8656 by restore_message. Value is non-zero if the current message isn't
8657 empty. This is a relatively infrequent operation, so it's not
8658 worth optimizing. */
8664 msg
= current_message ();
8665 Vmessage_stack
= Fcons (msg
, Vmessage_stack
);
8666 return STRINGP (msg
);
8670 /* Restore message display from the top of Vmessage_stack. */
8677 xassert (CONSP (Vmessage_stack
));
8678 msg
= XCAR (Vmessage_stack
);
8680 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
8682 message3_nolog (msg
, 0, 0);
8686 /* Handler for record_unwind_protect calling pop_message. */
8689 pop_message_unwind (dummy
)
8696 /* Pop the top-most entry off Vmessage_stack. */
8701 xassert (CONSP (Vmessage_stack
));
8702 Vmessage_stack
= XCDR (Vmessage_stack
);
8706 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
8707 exits. If the stack is not empty, we have a missing pop_message
8711 check_message_stack ()
8713 if (!NILP (Vmessage_stack
))
8718 /* Truncate to NCHARS what will be displayed in the echo area the next
8719 time we display it---but don't redisplay it now. */
8722 truncate_echo_area (nchars
)
8726 echo_area_buffer
[0] = Qnil
;
8727 /* A null message buffer means that the frame hasn't really been
8728 initialized yet. Error messages get reported properly by
8729 cmd_error, so this must be just an informative message; toss it. */
8730 else if (!noninteractive
8732 && !NILP (echo_area_buffer
[0]))
8734 struct frame
*sf
= SELECTED_FRAME ();
8735 if (FRAME_MESSAGE_BUF (sf
))
8736 with_echo_area_buffer (0, 0, truncate_message_1
, nchars
, Qnil
, 0, 0);
8741 /* Helper function for truncate_echo_area. Truncate the current
8742 message to at most NCHARS characters. */
8745 truncate_message_1 (nchars
, a2
, a3
, a4
)
8750 if (BEG
+ nchars
< Z
)
8751 del_range (BEG
+ nchars
, Z
);
8753 echo_area_buffer
[0] = Qnil
;
8758 /* Set the current message to a substring of S or STRING.
8760 If STRING is a Lisp string, set the message to the first NBYTES
8761 bytes from STRING. NBYTES zero means use the whole string. If
8762 STRING is multibyte, the message will be displayed multibyte.
8764 If S is not null, set the message to the first LEN bytes of S. LEN
8765 zero means use the whole string. MULTIBYTE_P non-zero means S is
8766 multibyte. Display the message multibyte in that case.
8768 Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
8769 to t before calling set_message_1 (which calls insert).
8773 set_message (s
, string
, nbytes
, multibyte_p
)
8776 int nbytes
, multibyte_p
;
8778 message_enable_multibyte
8779 = ((s
&& multibyte_p
)
8780 || (STRINGP (string
) && STRING_MULTIBYTE (string
)));
8782 with_echo_area_buffer (0, -1, set_message_1
,
8783 (EMACS_INT
) s
, string
, nbytes
, multibyte_p
);
8784 message_buf_print
= 0;
8785 help_echo_showing_p
= 0;
8789 /* Helper function for set_message. Arguments have the same meaning
8790 as there, with A1 corresponding to S and A2 corresponding to STRING
8791 This function is called with the echo area buffer being
8795 set_message_1 (a1
, a2
, nbytes
, multibyte_p
)
8798 EMACS_INT nbytes
, multibyte_p
;
8800 const char *s
= (const char *) a1
;
8801 Lisp_Object string
= a2
;
8803 /* Change multibyteness of the echo buffer appropriately. */
8804 if (message_enable_multibyte
8805 != !NILP (current_buffer
->enable_multibyte_characters
))
8806 Fset_buffer_multibyte (message_enable_multibyte
? Qt
: Qnil
);
8808 current_buffer
->truncate_lines
= message_truncate_lines
? Qt
: Qnil
;
8810 /* Insert new message at BEG. */
8811 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
8813 if (STRINGP (string
))
8818 nbytes
= SBYTES (string
);
8819 nchars
= string_byte_to_char (string
, nbytes
);
8821 /* This function takes care of single/multibyte conversion. We
8822 just have to ensure that the echo area buffer has the right
8823 setting of enable_multibyte_characters. */
8824 insert_from_string (string
, 0, 0, nchars
, nbytes
, 1);
8829 nbytes
= strlen (s
);
8831 if (multibyte_p
&& NILP (current_buffer
->enable_multibyte_characters
))
8833 /* Convert from multi-byte to single-byte. */
8835 unsigned char work
[1];
8837 /* Convert a multibyte string to single-byte. */
8838 for (i
= 0; i
< nbytes
; i
+= n
)
8840 c
= string_char_and_length (s
+ i
, nbytes
- i
, &n
);
8841 work
[0] = (ASCII_CHAR_P (c
)
8843 : multibyte_char_to_unibyte (c
, Qnil
));
8844 insert_1_both (work
, 1, 1, 1, 0, 0);
8847 else if (!multibyte_p
8848 && !NILP (current_buffer
->enable_multibyte_characters
))
8850 /* Convert from single-byte to multi-byte. */
8852 const unsigned char *msg
= (const unsigned char *) s
;
8853 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
8855 /* Convert a single-byte string to multibyte. */
8856 for (i
= 0; i
< nbytes
; i
++)
8859 c
= unibyte_char_to_multibyte (c
);
8860 n
= CHAR_STRING (c
, str
);
8861 insert_1_both (str
, 1, n
, 1, 0, 0);
8865 insert_1 (s
, nbytes
, 1, 0, 0);
8872 /* Clear messages. CURRENT_P non-zero means clear the current
8873 message. LAST_DISPLAYED_P non-zero means clear the message
8877 clear_message (current_p
, last_displayed_p
)
8878 int current_p
, last_displayed_p
;
8882 echo_area_buffer
[0] = Qnil
;
8883 message_cleared_p
= 1;
8886 if (last_displayed_p
)
8887 echo_area_buffer
[1] = Qnil
;
8889 message_buf_print
= 0;
8892 /* Clear garbaged frames.
8894 This function is used where the old redisplay called
8895 redraw_garbaged_frames which in turn called redraw_frame which in
8896 turn called clear_frame. The call to clear_frame was a source of
8897 flickering. I believe a clear_frame is not necessary. It should
8898 suffice in the new redisplay to invalidate all current matrices,
8899 and ensure a complete redisplay of all windows. */
8902 clear_garbaged_frames ()
8906 Lisp_Object tail
, frame
;
8907 int changed_count
= 0;
8909 FOR_EACH_FRAME (tail
, frame
)
8911 struct frame
*f
= XFRAME (frame
);
8913 if (FRAME_VISIBLE_P (f
) && FRAME_GARBAGED_P (f
))
8917 Fredraw_frame (frame
);
8918 f
->force_flush_display_p
= 1;
8920 clear_current_matrices (f
);
8929 ++windows_or_buffers_changed
;
8934 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
8935 is non-zero update selected_frame. Value is non-zero if the
8936 mini-windows height has been changed. */
8939 echo_area_display (update_frame_p
)
8942 Lisp_Object mini_window
;
8945 int window_height_changed_p
= 0;
8946 struct frame
*sf
= SELECTED_FRAME ();
8948 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8949 w
= XWINDOW (mini_window
);
8950 f
= XFRAME (WINDOW_FRAME (w
));
8952 /* Don't display if frame is invisible or not yet initialized. */
8953 if (!FRAME_VISIBLE_P (f
) || !f
->glyphs_initialized_p
)
8956 /* The terminal frame is used as the first Emacs frame on the Mac OS. */
8958 #ifdef HAVE_WINDOW_SYSTEM
8959 /* When Emacs starts, selected_frame may be the initial terminal
8960 frame. If we let this through, a message would be displayed on
8962 if (FRAME_INITIAL_P (XFRAME (selected_frame
)))
8964 #endif /* HAVE_WINDOW_SYSTEM */
8967 /* Redraw garbaged frames. */
8969 clear_garbaged_frames ();
8971 if (!NILP (echo_area_buffer
[0]) || minibuf_level
== 0)
8973 echo_area_window
= mini_window
;
8974 window_height_changed_p
= display_echo_area (w
);
8975 w
->must_be_updated_p
= 1;
8977 /* Update the display, unless called from redisplay_internal.
8978 Also don't update the screen during redisplay itself. The
8979 update will happen at the end of redisplay, and an update
8980 here could cause confusion. */
8981 if (update_frame_p
&& !redisplaying_p
)
8985 /* If the display update has been interrupted by pending
8986 input, update mode lines in the frame. Due to the
8987 pending input, it might have been that redisplay hasn't
8988 been called, so that mode lines above the echo area are
8989 garbaged. This looks odd, so we prevent it here. */
8990 if (!display_completed
)
8991 n
= redisplay_mode_lines (FRAME_ROOT_WINDOW (f
), 0);
8993 if (window_height_changed_p
8994 /* Don't do this if Emacs is shutting down. Redisplay
8995 needs to run hooks. */
8996 && !NILP (Vrun_hooks
))
8998 /* Must update other windows. Likewise as in other
8999 cases, don't let this update be interrupted by
9001 int count
= SPECPDL_INDEX ();
9002 specbind (Qredisplay_dont_pause
, Qt
);
9003 windows_or_buffers_changed
= 1;
9004 redisplay_internal (0);
9005 unbind_to (count
, Qnil
);
9007 else if (FRAME_WINDOW_P (f
) && n
== 0)
9009 /* Window configuration is the same as before.
9010 Can do with a display update of the echo area,
9011 unless we displayed some mode lines. */
9012 update_single_window (w
, 1);
9013 FRAME_RIF (f
)->flush_display (f
);
9016 update_frame (f
, 1, 1);
9018 /* If cursor is in the echo area, make sure that the next
9019 redisplay displays the minibuffer, so that the cursor will
9020 be replaced with what the minibuffer wants. */
9021 if (cursor_in_echo_area
)
9022 ++windows_or_buffers_changed
;
9025 else if (!EQ (mini_window
, selected_window
))
9026 windows_or_buffers_changed
++;
9028 /* Last displayed message is now the current message. */
9029 echo_area_buffer
[1] = echo_area_buffer
[0];
9030 /* Inform read_char that we're not echoing. */
9031 echo_message_buffer
= Qnil
;
9033 /* Prevent redisplay optimization in redisplay_internal by resetting
9034 this_line_start_pos. This is done because the mini-buffer now
9035 displays the message instead of its buffer text. */
9036 if (EQ (mini_window
, selected_window
))
9037 CHARPOS (this_line_start_pos
) = 0;
9039 return window_height_changed_p
;
9044 /***********************************************************************
9045 Mode Lines and Frame Titles
9046 ***********************************************************************/
9048 /* A buffer for constructing non-propertized mode-line strings and
9049 frame titles in it; allocated from the heap in init_xdisp and
9050 resized as needed in store_mode_line_noprop_char. */
9052 static char *mode_line_noprop_buf
;
9054 /* The buffer's end, and a current output position in it. */
9056 static char *mode_line_noprop_buf_end
;
9057 static char *mode_line_noprop_ptr
;
9059 #define MODE_LINE_NOPROP_LEN(start) \
9060 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
9063 MODE_LINE_DISPLAY
= 0,
9069 /* Alist that caches the results of :propertize.
9070 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
9071 static Lisp_Object mode_line_proptrans_alist
;
9073 /* List of strings making up the mode-line. */
9074 static Lisp_Object mode_line_string_list
;
9076 /* Base face property when building propertized mode line string. */
9077 static Lisp_Object mode_line_string_face
;
9078 static Lisp_Object mode_line_string_face_prop
;
9081 /* Unwind data for mode line strings */
9083 static Lisp_Object Vmode_line_unwind_vector
;
9086 format_mode_line_unwind_data (obuf
, save_proptrans
)
9087 struct buffer
*obuf
;
9091 /* Reduce consing by keeping one vector in
9092 Vwith_echo_area_save_vector. */
9093 vector
= Vmode_line_unwind_vector
;
9094 Vmode_line_unwind_vector
= Qnil
;
9097 vector
= Fmake_vector (make_number (7), Qnil
);
9099 AREF (vector
, 0) = make_number (mode_line_target
);
9100 AREF (vector
, 1) = make_number (MODE_LINE_NOPROP_LEN (0));
9101 AREF (vector
, 2) = mode_line_string_list
;
9102 AREF (vector
, 3) = (save_proptrans
? mode_line_proptrans_alist
: Qt
);
9103 AREF (vector
, 4) = mode_line_string_face
;
9104 AREF (vector
, 5) = mode_line_string_face_prop
;
9107 XSETBUFFER (AREF (vector
, 6), obuf
);
9109 AREF (vector
, 6) = Qnil
;
9115 unwind_format_mode_line (vector
)
9118 mode_line_target
= XINT (AREF (vector
, 0));
9119 mode_line_noprop_ptr
= mode_line_noprop_buf
+ XINT (AREF (vector
, 1));
9120 mode_line_string_list
= AREF (vector
, 2);
9121 if (! EQ (AREF (vector
, 3), Qt
))
9122 mode_line_proptrans_alist
= AREF (vector
, 3);
9123 mode_line_string_face
= AREF (vector
, 4);
9124 mode_line_string_face_prop
= AREF (vector
, 5);
9126 if (!NILP (AREF (vector
, 6)))
9128 set_buffer_internal_1 (XBUFFER (AREF (vector
, 6)));
9129 AREF (vector
, 6) = Qnil
;
9132 Vmode_line_unwind_vector
= vector
;
9137 /* Store a single character C for the frame title in mode_line_noprop_buf.
9138 Re-allocate mode_line_noprop_buf if necessary. */
9142 store_mode_line_noprop_char (char c
)
9144 store_mode_line_noprop_char (c
)
9148 /* If output position has reached the end of the allocated buffer,
9149 double the buffer's size. */
9150 if (mode_line_noprop_ptr
== mode_line_noprop_buf_end
)
9152 int len
= MODE_LINE_NOPROP_LEN (0);
9153 int new_size
= 2 * len
* sizeof *mode_line_noprop_buf
;
9154 mode_line_noprop_buf
= (char *) xrealloc (mode_line_noprop_buf
, new_size
);
9155 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ new_size
;
9156 mode_line_noprop_ptr
= mode_line_noprop_buf
+ len
;
9159 *mode_line_noprop_ptr
++ = c
;
9163 /* Store part of a frame title in mode_line_noprop_buf, beginning at
9164 mode_line_noprop_ptr. STR is the string to store. Do not copy
9165 characters that yield more columns than PRECISION; PRECISION <= 0
9166 means copy the whole string. Pad with spaces until FIELD_WIDTH
9167 number of characters have been copied; FIELD_WIDTH <= 0 means don't
9168 pad. Called from display_mode_element when it is used to build a
9172 store_mode_line_noprop (str
, field_width
, precision
)
9173 const unsigned char *str
;
9174 int field_width
, precision
;
9179 /* Copy at most PRECISION chars from STR. */
9180 nbytes
= strlen (str
);
9181 n
+= c_string_width (str
, nbytes
, precision
, &dummy
, &nbytes
);
9183 store_mode_line_noprop_char (*str
++);
9185 /* Fill up with spaces until FIELD_WIDTH reached. */
9186 while (field_width
> 0
9189 store_mode_line_noprop_char (' ');
9196 /***********************************************************************
9198 ***********************************************************************/
9200 #ifdef HAVE_WINDOW_SYSTEM
9202 /* Set the title of FRAME, if it has changed. The title format is
9203 Vicon_title_format if FRAME is iconified, otherwise it is
9204 frame_title_format. */
9207 x_consider_frame_title (frame
)
9210 struct frame
*f
= XFRAME (frame
);
9212 if (FRAME_WINDOW_P (f
)
9213 || FRAME_MINIBUF_ONLY_P (f
)
9214 || f
->explicit_name
)
9216 /* Do we have more than one visible frame on this X display? */
9223 int count
= SPECPDL_INDEX ();
9225 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
9227 Lisp_Object other_frame
= XCAR (tail
);
9228 struct frame
*tf
= XFRAME (other_frame
);
9231 && FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
9232 && !FRAME_MINIBUF_ONLY_P (tf
)
9233 && !EQ (other_frame
, tip_frame
)
9234 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
9238 /* Set global variable indicating that multiple frames exist. */
9239 multiple_frames
= CONSP (tail
);
9241 /* Switch to the buffer of selected window of the frame. Set up
9242 mode_line_target so that display_mode_element will output into
9243 mode_line_noprop_buf; then display the title. */
9244 record_unwind_protect (unwind_format_mode_line
,
9245 format_mode_line_unwind_data (current_buffer
, 0));
9247 set_buffer_internal_1 (XBUFFER (XWINDOW (f
->selected_window
)->buffer
));
9248 fmt
= FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
;
9250 mode_line_target
= MODE_LINE_TITLE
;
9251 title_start
= MODE_LINE_NOPROP_LEN (0);
9252 init_iterator (&it
, XWINDOW (f
->selected_window
), -1, -1,
9253 NULL
, DEFAULT_FACE_ID
);
9254 display_mode_element (&it
, 0, -1, -1, fmt
, Qnil
, 0);
9255 len
= MODE_LINE_NOPROP_LEN (title_start
);
9256 title
= mode_line_noprop_buf
+ title_start
;
9257 unbind_to (count
, Qnil
);
9259 /* Set the title only if it's changed. This avoids consing in
9260 the common case where it hasn't. (If it turns out that we've
9261 already wasted too much time by walking through the list with
9262 display_mode_element, then we might need to optimize at a
9263 higher level than this.) */
9264 if (! STRINGP (f
->name
)
9265 || SBYTES (f
->name
) != len
9266 || bcmp (title
, SDATA (f
->name
), len
) != 0)
9267 x_implicitly_set_name (f
, make_string (title
, len
), Qnil
);
9271 #endif /* not HAVE_WINDOW_SYSTEM */
9276 /***********************************************************************
9278 ***********************************************************************/
9281 /* Prepare for redisplay by updating menu-bar item lists when
9282 appropriate. This can call eval. */
9285 prepare_menu_bars ()
9288 struct gcpro gcpro1
, gcpro2
;
9290 Lisp_Object tooltip_frame
;
9292 #ifdef HAVE_WINDOW_SYSTEM
9293 tooltip_frame
= tip_frame
;
9295 tooltip_frame
= Qnil
;
9298 /* Update all frame titles based on their buffer names, etc. We do
9299 this before the menu bars so that the buffer-menu will show the
9300 up-to-date frame titles. */
9301 #ifdef HAVE_WINDOW_SYSTEM
9302 if (windows_or_buffers_changed
|| update_mode_lines
)
9304 Lisp_Object tail
, frame
;
9306 FOR_EACH_FRAME (tail
, frame
)
9309 if (!EQ (frame
, tooltip_frame
)
9310 && (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)))
9311 x_consider_frame_title (frame
);
9314 #endif /* HAVE_WINDOW_SYSTEM */
9316 /* Update the menu bar item lists, if appropriate. This has to be
9317 done before any actual redisplay or generation of display lines. */
9318 all_windows
= (update_mode_lines
9319 || buffer_shared
> 1
9320 || windows_or_buffers_changed
);
9323 Lisp_Object tail
, frame
;
9324 int count
= SPECPDL_INDEX ();
9325 /* 1 means that update_menu_bar has run its hooks
9326 so any further calls to update_menu_bar shouldn't do so again. */
9327 int menu_bar_hooks_run
= 0;
9329 record_unwind_save_match_data ();
9331 FOR_EACH_FRAME (tail
, frame
)
9335 /* Ignore tooltip frame. */
9336 if (EQ (frame
, tooltip_frame
))
9339 /* If a window on this frame changed size, report that to
9340 the user and clear the size-change flag. */
9341 if (FRAME_WINDOW_SIZES_CHANGED (f
))
9343 Lisp_Object functions
;
9345 /* Clear flag first in case we get an error below. */
9346 FRAME_WINDOW_SIZES_CHANGED (f
) = 0;
9347 functions
= Vwindow_size_change_functions
;
9348 GCPRO2 (tail
, functions
);
9350 while (CONSP (functions
))
9352 call1 (XCAR (functions
), frame
);
9353 functions
= XCDR (functions
);
9359 menu_bar_hooks_run
= update_menu_bar (f
, 0, menu_bar_hooks_run
);
9360 #ifdef HAVE_WINDOW_SYSTEM
9361 update_tool_bar (f
, 0);
9363 mac_update_title_bar (f
, 0);
9369 unbind_to (count
, Qnil
);
9373 struct frame
*sf
= SELECTED_FRAME ();
9374 update_menu_bar (sf
, 1, 0);
9375 #ifdef HAVE_WINDOW_SYSTEM
9376 update_tool_bar (sf
, 1);
9378 mac_update_title_bar (sf
, 1);
9383 /* Motif needs this. See comment in xmenu.c. Turn it off when
9384 pending_menu_activation is not defined. */
9385 #ifdef USE_X_TOOLKIT
9386 pending_menu_activation
= 0;
9391 /* Update the menu bar item list for frame F. This has to be done
9392 before we start to fill in any display lines, because it can call
9395 If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
9397 If HOOKS_RUN is 1, that means a previous call to update_menu_bar
9398 already ran the menu bar hooks for this redisplay, so there
9399 is no need to run them again. The return value is the
9400 updated value of this flag, to pass to the next call. */
9403 update_menu_bar (f
, save_match_data
, hooks_run
)
9405 int save_match_data
;
9409 register struct window
*w
;
9411 /* If called recursively during a menu update, do nothing. This can
9412 happen when, for instance, an activate-menubar-hook causes a
9414 if (inhibit_menubar_update
)
9417 window
= FRAME_SELECTED_WINDOW (f
);
9418 w
= XWINDOW (window
);
9420 #if 0 /* The if statement below this if statement used to include the
9421 condition !NILP (w->update_mode_line), rather than using
9422 update_mode_lines directly, and this if statement may have
9423 been added to make that condition work. Now the if
9424 statement below matches its comment, this isn't needed. */
9425 if (update_mode_lines
)
9426 w
->update_mode_line
= Qt
;
9429 if (FRAME_WINDOW_P (f
)
9431 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
9432 || defined (USE_GTK)
9433 FRAME_EXTERNAL_MENU_BAR (f
)
9435 FRAME_MENU_BAR_LINES (f
) > 0
9437 : FRAME_MENU_BAR_LINES (f
) > 0)
9439 /* If the user has switched buffers or windows, we need to
9440 recompute to reflect the new bindings. But we'll
9441 recompute when update_mode_lines is set too; that means
9442 that people can use force-mode-line-update to request
9443 that the menu bar be recomputed. The adverse effect on
9444 the rest of the redisplay algorithm is about the same as
9445 windows_or_buffers_changed anyway. */
9446 if (windows_or_buffers_changed
9447 /* This used to test w->update_mode_line, but we believe
9448 there is no need to recompute the menu in that case. */
9449 || update_mode_lines
9450 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
9451 < BUF_MODIFF (XBUFFER (w
->buffer
)))
9452 != !NILP (w
->last_had_star
))
9453 || ((!NILP (Vtransient_mark_mode
)
9454 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
9455 != !NILP (w
->region_showing
)))
9457 struct buffer
*prev
= current_buffer
;
9458 int count
= SPECPDL_INDEX ();
9460 specbind (Qinhibit_menubar_update
, Qt
);
9462 set_buffer_internal_1 (XBUFFER (w
->buffer
));
9463 if (save_match_data
)
9464 record_unwind_save_match_data ();
9465 if (NILP (Voverriding_local_map_menu_flag
))
9467 specbind (Qoverriding_terminal_local_map
, Qnil
);
9468 specbind (Qoverriding_local_map
, Qnil
);
9473 /* Run the Lucid hook. */
9474 safe_run_hooks (Qactivate_menubar_hook
);
9476 /* If it has changed current-menubar from previous value,
9477 really recompute the menu-bar from the value. */
9478 if (! NILP (Vlucid_menu_bar_dirty_flag
))
9479 call0 (Qrecompute_lucid_menubar
);
9481 safe_run_hooks (Qmenu_bar_update_hook
);
9486 XSETFRAME (Vmenu_updating_frame
, f
);
9487 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
9489 /* Redisplay the menu bar in case we changed it. */
9490 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
9491 || defined (USE_GTK)
9492 if (FRAME_WINDOW_P (f
))
9495 /* All frames on Mac OS share the same menubar. So only
9496 the selected frame should be allowed to set it. */
9497 if (f
== SELECTED_FRAME ())
9499 set_frame_menubar (f
, 0, 0);
9502 /* On a terminal screen, the menu bar is an ordinary screen
9503 line, and this makes it get updated. */
9504 w
->update_mode_line
= Qt
;
9505 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || MAC_OS || USE_GTK) */
9506 /* In the non-toolkit version, the menu bar is an ordinary screen
9507 line, and this makes it get updated. */
9508 w
->update_mode_line
= Qt
;
9509 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || MAC_OS || USE_GTK) */
9511 unbind_to (count
, Qnil
);
9512 set_buffer_internal_1 (prev
);
9521 /***********************************************************************
9523 ***********************************************************************/
9525 #ifdef HAVE_WINDOW_SYSTEM
9528 Nominal cursor position -- where to draw output.
9529 HPOS and VPOS are window relative glyph matrix coordinates.
9530 X and Y are window relative pixel coordinates. */
9532 struct cursor_pos output_cursor
;
9536 Set the global variable output_cursor to CURSOR. All cursor
9537 positions are relative to updated_window. */
9540 set_output_cursor (cursor
)
9541 struct cursor_pos
*cursor
;
9543 output_cursor
.hpos
= cursor
->hpos
;
9544 output_cursor
.vpos
= cursor
->vpos
;
9545 output_cursor
.x
= cursor
->x
;
9546 output_cursor
.y
= cursor
->y
;
9551 Set a nominal cursor position.
9553 HPOS and VPOS are column/row positions in a window glyph matrix. X
9554 and Y are window text area relative pixel positions.
9556 If this is done during an update, updated_window will contain the
9557 window that is being updated and the position is the future output
9558 cursor position for that window. If updated_window is null, use
9559 selected_window and display the cursor at the given position. */
9562 x_cursor_to (vpos
, hpos
, y
, x
)
9563 int vpos
, hpos
, y
, x
;
9567 /* If updated_window is not set, work on selected_window. */
9571 w
= XWINDOW (selected_window
);
9573 /* Set the output cursor. */
9574 output_cursor
.hpos
= hpos
;
9575 output_cursor
.vpos
= vpos
;
9576 output_cursor
.x
= x
;
9577 output_cursor
.y
= y
;
9579 /* If not called as part of an update, really display the cursor.
9580 This will also set the cursor position of W. */
9581 if (updated_window
== NULL
)
9584 display_and_set_cursor (w
, 1, hpos
, vpos
, x
, y
);
9585 if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
9586 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
9591 #endif /* HAVE_WINDOW_SYSTEM */
9594 /***********************************************************************
9596 ***********************************************************************/
9598 #ifdef HAVE_WINDOW_SYSTEM
9600 /* Where the mouse was last time we reported a mouse event. */
9602 FRAME_PTR last_mouse_frame
;
9604 /* Tool-bar item index of the item on which a mouse button was pressed
9607 int last_tool_bar_item
;
9610 /* Update the tool-bar item list for frame F. This has to be done
9611 before we start to fill in any display lines. Called from
9612 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
9613 and restore it here. */
9616 update_tool_bar (f
, save_match_data
)
9618 int save_match_data
;
9620 #if defined (USE_GTK) || USE_MAC_TOOLBAR
9621 int do_update
= FRAME_EXTERNAL_TOOL_BAR (f
);
9623 int do_update
= WINDOWP (f
->tool_bar_window
)
9624 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0;
9632 window
= FRAME_SELECTED_WINDOW (f
);
9633 w
= XWINDOW (window
);
9635 /* If the user has switched buffers or windows, we need to
9636 recompute to reflect the new bindings. But we'll
9637 recompute when update_mode_lines is set too; that means
9638 that people can use force-mode-line-update to request
9639 that the menu bar be recomputed. The adverse effect on
9640 the rest of the redisplay algorithm is about the same as
9641 windows_or_buffers_changed anyway. */
9642 if (windows_or_buffers_changed
9643 || !NILP (w
->update_mode_line
)
9644 || update_mode_lines
9645 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
9646 < BUF_MODIFF (XBUFFER (w
->buffer
)))
9647 != !NILP (w
->last_had_star
))
9648 || ((!NILP (Vtransient_mark_mode
)
9649 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
9650 != !NILP (w
->region_showing
)))
9652 struct buffer
*prev
= current_buffer
;
9653 int count
= SPECPDL_INDEX ();
9654 Lisp_Object new_tool_bar
;
9656 struct gcpro gcpro1
;
9658 /* Set current_buffer to the buffer of the selected
9659 window of the frame, so that we get the right local
9661 set_buffer_internal_1 (XBUFFER (w
->buffer
));
9663 /* Save match data, if we must. */
9664 if (save_match_data
)
9665 record_unwind_save_match_data ();
9667 /* Make sure that we don't accidentally use bogus keymaps. */
9668 if (NILP (Voverriding_local_map_menu_flag
))
9670 specbind (Qoverriding_terminal_local_map
, Qnil
);
9671 specbind (Qoverriding_local_map
, Qnil
);
9674 GCPRO1 (new_tool_bar
);
9676 /* Build desired tool-bar items from keymaps. */
9677 new_tool_bar
= tool_bar_items (Fcopy_sequence (f
->tool_bar_items
),
9680 /* Redisplay the tool-bar if we changed it. */
9681 if (new_n_tool_bar
!= f
->n_tool_bar_items
9682 || NILP (Fequal (new_tool_bar
, f
->tool_bar_items
)))
9684 /* Redisplay that happens asynchronously due to an expose event
9685 may access f->tool_bar_items. Make sure we update both
9686 variables within BLOCK_INPUT so no such event interrupts. */
9688 f
->tool_bar_items
= new_tool_bar
;
9689 f
->n_tool_bar_items
= new_n_tool_bar
;
9690 w
->update_mode_line
= Qt
;
9696 unbind_to (count
, Qnil
);
9697 set_buffer_internal_1 (prev
);
9703 /* Set F->desired_tool_bar_string to a Lisp string representing frame
9704 F's desired tool-bar contents. F->tool_bar_items must have
9705 been set up previously by calling prepare_menu_bars. */
9708 build_desired_tool_bar_string (f
)
9711 int i
, size
, size_needed
;
9712 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9713 Lisp_Object image
, plist
, props
;
9715 image
= plist
= props
= Qnil
;
9716 GCPRO3 (image
, plist
, props
);
9718 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
9719 Otherwise, make a new string. */
9721 /* The size of the string we might be able to reuse. */
9722 size
= (STRINGP (f
->desired_tool_bar_string
)
9723 ? SCHARS (f
->desired_tool_bar_string
)
9726 /* We need one space in the string for each image. */
9727 size_needed
= f
->n_tool_bar_items
;
9729 /* Reuse f->desired_tool_bar_string, if possible. */
9730 if (size
< size_needed
|| NILP (f
->desired_tool_bar_string
))
9731 f
->desired_tool_bar_string
= Fmake_string (make_number (size_needed
),
9735 props
= list4 (Qdisplay
, Qnil
, Qmenu_item
, Qnil
);
9736 Fremove_text_properties (make_number (0), make_number (size
),
9737 props
, f
->desired_tool_bar_string
);
9740 /* Put a `display' property on the string for the images to display,
9741 put a `menu_item' property on tool-bar items with a value that
9742 is the index of the item in F's tool-bar item vector. */
9743 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
9745 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
9747 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
9748 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
9749 int hmargin
, vmargin
, relief
, idx
, end
;
9750 extern Lisp_Object QCrelief
, QCmargin
, QCconversion
;
9752 /* If image is a vector, choose the image according to the
9754 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
9755 if (VECTORP (image
))
9759 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
9760 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
9763 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
9764 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
9766 xassert (ASIZE (image
) >= idx
);
9767 image
= AREF (image
, idx
);
9772 /* Ignore invalid image specifications. */
9773 if (!valid_image_p (image
))
9776 /* Display the tool-bar button pressed, or depressed. */
9777 plist
= Fcopy_sequence (XCDR (image
));
9779 /* Compute margin and relief to draw. */
9780 relief
= (tool_bar_button_relief
>= 0
9781 ? tool_bar_button_relief
9782 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
9783 hmargin
= vmargin
= relief
;
9785 if (INTEGERP (Vtool_bar_button_margin
)
9786 && XINT (Vtool_bar_button_margin
) > 0)
9788 hmargin
+= XFASTINT (Vtool_bar_button_margin
);
9789 vmargin
+= XFASTINT (Vtool_bar_button_margin
);
9791 else if (CONSP (Vtool_bar_button_margin
))
9793 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
9794 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
9795 hmargin
+= XFASTINT (XCAR (Vtool_bar_button_margin
));
9797 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
9798 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
9799 vmargin
+= XFASTINT (XCDR (Vtool_bar_button_margin
));
9802 if (auto_raise_tool_bar_buttons_p
)
9804 /* Add a `:relief' property to the image spec if the item is
9808 plist
= Fplist_put (plist
, QCrelief
, make_number (-relief
));
9815 /* If image is selected, display it pressed, i.e. with a
9816 negative relief. If it's not selected, display it with a
9818 plist
= Fplist_put (plist
, QCrelief
,
9820 ? make_number (-relief
)
9821 : make_number (relief
)));
9826 /* Put a margin around the image. */
9827 if (hmargin
|| vmargin
)
9829 if (hmargin
== vmargin
)
9830 plist
= Fplist_put (plist
, QCmargin
, make_number (hmargin
));
9832 plist
= Fplist_put (plist
, QCmargin
,
9833 Fcons (make_number (hmargin
),
9834 make_number (vmargin
)));
9837 /* If button is not enabled, and we don't have special images
9838 for the disabled state, make the image appear disabled by
9839 applying an appropriate algorithm to it. */
9840 if (!enabled_p
&& idx
< 0)
9841 plist
= Fplist_put (plist
, QCconversion
, Qdisabled
);
9843 /* Put a `display' text property on the string for the image to
9844 display. Put a `menu-item' property on the string that gives
9845 the start of this item's properties in the tool-bar items
9847 image
= Fcons (Qimage
, plist
);
9848 props
= list4 (Qdisplay
, image
,
9849 Qmenu_item
, make_number (i
* TOOL_BAR_ITEM_NSLOTS
));
9851 /* Let the last image hide all remaining spaces in the tool bar
9852 string. The string can be longer than needed when we reuse a
9854 if (i
+ 1 == f
->n_tool_bar_items
)
9855 end
= SCHARS (f
->desired_tool_bar_string
);
9858 Fadd_text_properties (make_number (i
), make_number (end
),
9859 props
, f
->desired_tool_bar_string
);
9867 /* Display one line of the tool-bar of frame IT->f.
9869 HEIGHT specifies the desired height of the tool-bar line.
9870 If the actual height of the glyph row is less than HEIGHT, the
9871 row's height is increased to HEIGHT, and the icons are centered
9872 vertically in the new height.
9874 If HEIGHT is -1, we are counting needed tool-bar lines, so don't
9875 count a final empty row in case the tool-bar width exactly matches
9880 display_tool_bar_line (it
, height
)
9884 struct glyph_row
*row
= it
->glyph_row
;
9885 int max_x
= it
->last_visible_x
;
9888 prepare_desired_row (row
);
9889 row
->y
= it
->current_y
;
9891 /* Note that this isn't made use of if the face hasn't a box,
9892 so there's no need to check the face here. */
9893 it
->start_of_box_run_p
= 1;
9895 while (it
->current_x
< max_x
)
9897 int x
, n_glyphs_before
, i
, nglyphs
;
9898 struct it it_before
;
9900 /* Get the next display element. */
9901 if (!get_next_display_element (it
))
9903 /* Don't count empty row if we are counting needed tool-bar lines. */
9904 if (height
< 0 && !it
->hpos
)
9909 /* Produce glyphs. */
9910 n_glyphs_before
= row
->used
[TEXT_AREA
];
9913 PRODUCE_GLYPHS (it
);
9915 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
9917 x
= it_before
.current_x
;
9920 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
9922 if (x
+ glyph
->pixel_width
> max_x
)
9924 /* Glyph doesn't fit on line. Backtrack. */
9925 row
->used
[TEXT_AREA
] = n_glyphs_before
;
9927 /* If this is the only glyph on this line, it will never fit on the
9928 toolbar, so skip it. But ensure there is at least one glyph,
9929 so we don't accidentally disable the tool-bar. */
9930 if (n_glyphs_before
== 0
9931 && (it
->vpos
> 0 || IT_STRING_CHARPOS (*it
) < it
->end_charpos
-1))
9937 x
+= glyph
->pixel_width
;
9941 /* Stop at line ends. */
9942 if (ITERATOR_AT_END_OF_LINE_P (it
))
9945 set_iterator_to_next (it
, 1);
9950 row
->displays_text_p
= row
->used
[TEXT_AREA
] != 0;
9952 /* Use default face for the border below the tool bar.
9954 FIXME: When auto-resize-tool-bars is grow-only, there is
9955 no additional border below the possibly empty tool-bar lines.
9956 So to make the extra empty lines look "normal", we have to
9957 use the tool-bar face for the border too. */
9958 if (!row
->displays_text_p
&& !EQ (Vauto_resize_tool_bars
, Qgrow_only
))
9959 it
->face_id
= DEFAULT_FACE_ID
;
9961 extend_face_to_end_of_line (it
);
9962 last
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
9963 last
->right_box_line_p
= 1;
9964 if (last
== row
->glyphs
[TEXT_AREA
])
9965 last
->left_box_line_p
= 1;
9967 /* Make line the desired height and center it vertically. */
9968 if ((height
-= it
->max_ascent
+ it
->max_descent
) > 0)
9970 /* Don't add more than one line height. */
9971 height
%= FRAME_LINE_HEIGHT (it
->f
);
9972 it
->max_ascent
+= height
/ 2;
9973 it
->max_descent
+= (height
+ 1) / 2;
9976 compute_line_metrics (it
);
9978 /* If line is empty, make it occupy the rest of the tool-bar. */
9979 if (!row
->displays_text_p
)
9981 row
->height
= row
->phys_height
= it
->last_visible_y
- row
->y
;
9982 row
->visible_height
= row
->height
;
9983 row
->ascent
= row
->phys_ascent
= 0;
9984 row
->extra_line_spacing
= 0;
9987 row
->full_width_p
= 1;
9988 row
->continued_p
= 0;
9989 row
->truncated_on_left_p
= 0;
9990 row
->truncated_on_right_p
= 0;
9992 it
->current_x
= it
->hpos
= 0;
9993 it
->current_y
+= row
->height
;
9999 /* Max tool-bar height. */
10001 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
10002 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
10004 /* Value is the number of screen lines needed to make all tool-bar
10005 items of frame F visible. The number of actual rows needed is
10006 returned in *N_ROWS if non-NULL. */
10009 tool_bar_lines_needed (f
, n_rows
)
10013 struct window
*w
= XWINDOW (f
->tool_bar_window
);
10015 /* tool_bar_lines_needed is called from redisplay_tool_bar after building
10016 the desired matrix, so use (unused) mode-line row as temporary row to
10017 avoid destroying the first tool-bar row. */
10018 struct glyph_row
*temp_row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
10020 /* Initialize an iterator for iteration over
10021 F->desired_tool_bar_string in the tool-bar window of frame F. */
10022 init_iterator (&it
, w
, -1, -1, temp_row
, TOOL_BAR_FACE_ID
);
10023 it
.first_visible_x
= 0;
10024 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
10025 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
10027 while (!ITERATOR_AT_END_P (&it
))
10029 clear_glyph_row (temp_row
);
10030 it
.glyph_row
= temp_row
;
10031 display_tool_bar_line (&it
, -1);
10033 clear_glyph_row (temp_row
);
10035 /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar. */
10037 *n_rows
= it
.vpos
> 0 ? it
.vpos
: -1;
10039 return (it
.current_y
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
10043 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed
, Stool_bar_lines_needed
,
10045 doc
: /* Return the number of lines occupied by the tool bar of FRAME. */)
10054 frame
= selected_frame
;
10056 CHECK_FRAME (frame
);
10057 f
= XFRAME (frame
);
10059 if (WINDOWP (f
->tool_bar_window
)
10060 || (w
= XWINDOW (f
->tool_bar_window
),
10061 WINDOW_TOTAL_LINES (w
) > 0))
10063 update_tool_bar (f
, 1);
10064 if (f
->n_tool_bar_items
)
10066 build_desired_tool_bar_string (f
);
10067 nlines
= tool_bar_lines_needed (f
, NULL
);
10071 return make_number (nlines
);
10075 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
10076 height should be changed. */
10079 redisplay_tool_bar (f
)
10084 struct glyph_row
*row
;
10086 #if defined (USE_GTK) || USE_MAC_TOOLBAR
10087 if (FRAME_EXTERNAL_TOOL_BAR (f
))
10088 update_frame_tool_bar (f
);
10092 /* If frame hasn't a tool-bar window or if it is zero-height, don't
10093 do anything. This means you must start with tool-bar-lines
10094 non-zero to get the auto-sizing effect. Or in other words, you
10095 can turn off tool-bars by specifying tool-bar-lines zero. */
10096 if (!WINDOWP (f
->tool_bar_window
)
10097 || (w
= XWINDOW (f
->tool_bar_window
),
10098 WINDOW_TOTAL_LINES (w
) == 0))
10101 /* Set up an iterator for the tool-bar window. */
10102 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
10103 it
.first_visible_x
= 0;
10104 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
10105 row
= it
.glyph_row
;
10107 /* Build a string that represents the contents of the tool-bar. */
10108 build_desired_tool_bar_string (f
);
10109 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
10111 if (f
->n_tool_bar_rows
== 0)
10115 if ((nlines
= tool_bar_lines_needed (f
, &f
->n_tool_bar_rows
),
10116 nlines
!= WINDOW_TOTAL_LINES (w
)))
10118 extern Lisp_Object Qtool_bar_lines
;
10120 int old_height
= WINDOW_TOTAL_LINES (w
);
10122 XSETFRAME (frame
, f
);
10123 Fmodify_frame_parameters (frame
,
10124 Fcons (Fcons (Qtool_bar_lines
,
10125 make_number (nlines
)),
10127 if (WINDOW_TOTAL_LINES (w
) != old_height
)
10129 clear_glyph_matrix (w
->desired_matrix
);
10130 fonts_changed_p
= 1;
10136 /* Display as many lines as needed to display all tool-bar items. */
10138 if (f
->n_tool_bar_rows
> 0)
10140 int border
, rows
, height
, extra
;
10142 if (INTEGERP (Vtool_bar_border
))
10143 border
= XINT (Vtool_bar_border
);
10144 else if (EQ (Vtool_bar_border
, Qinternal_border_width
))
10145 border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
10146 else if (EQ (Vtool_bar_border
, Qborder_width
))
10147 border
= f
->border_width
;
10153 rows
= f
->n_tool_bar_rows
;
10154 height
= max (1, (it
.last_visible_y
- border
) / rows
);
10155 extra
= it
.last_visible_y
- border
- height
* rows
;
10157 while (it
.current_y
< it
.last_visible_y
)
10160 if (extra
> 0 && rows
-- > 0)
10162 h
= (extra
+ rows
- 1) / rows
;
10165 display_tool_bar_line (&it
, height
+ h
);
10170 while (it
.current_y
< it
.last_visible_y
)
10171 display_tool_bar_line (&it
, 0);
10174 /* It doesn't make much sense to try scrolling in the tool-bar
10175 window, so don't do it. */
10176 w
->desired_matrix
->no_scrolling_p
= 1;
10177 w
->must_be_updated_p
= 1;
10179 if (!NILP (Vauto_resize_tool_bars
))
10181 int max_tool_bar_height
= MAX_FRAME_TOOL_BAR_HEIGHT (f
);
10182 int change_height_p
= 0;
10184 /* If we couldn't display everything, change the tool-bar's
10185 height if there is room for more. */
10186 if (IT_STRING_CHARPOS (it
) < it
.end_charpos
10187 && it
.current_y
< max_tool_bar_height
)
10188 change_height_p
= 1;
10190 row
= it
.glyph_row
- 1;
10192 /* If there are blank lines at the end, except for a partially
10193 visible blank line at the end that is smaller than
10194 FRAME_LINE_HEIGHT, change the tool-bar's height. */
10195 if (!row
->displays_text_p
10196 && row
->height
>= FRAME_LINE_HEIGHT (f
))
10197 change_height_p
= 1;
10199 /* If row displays tool-bar items, but is partially visible,
10200 change the tool-bar's height. */
10201 if (row
->displays_text_p
10202 && MATRIX_ROW_BOTTOM_Y (row
) > it
.last_visible_y
10203 && MATRIX_ROW_BOTTOM_Y (row
) < max_tool_bar_height
)
10204 change_height_p
= 1;
10206 /* Resize windows as needed by changing the `tool-bar-lines'
10207 frame parameter. */
10208 if (change_height_p
)
10210 extern Lisp_Object Qtool_bar_lines
;
10212 int old_height
= WINDOW_TOTAL_LINES (w
);
10214 int nlines
= tool_bar_lines_needed (f
, &nrows
);
10216 change_height_p
= ((EQ (Vauto_resize_tool_bars
, Qgrow_only
)
10217 && !f
->minimize_tool_bar_window_p
)
10218 ? (nlines
> old_height
)
10219 : (nlines
!= old_height
));
10220 f
->minimize_tool_bar_window_p
= 0;
10222 if (change_height_p
)
10224 XSETFRAME (frame
, f
);
10225 Fmodify_frame_parameters (frame
,
10226 Fcons (Fcons (Qtool_bar_lines
,
10227 make_number (nlines
)),
10229 if (WINDOW_TOTAL_LINES (w
) != old_height
)
10231 clear_glyph_matrix (w
->desired_matrix
);
10232 f
->n_tool_bar_rows
= nrows
;
10233 fonts_changed_p
= 1;
10240 f
->minimize_tool_bar_window_p
= 0;
10245 /* Get information about the tool-bar item which is displayed in GLYPH
10246 on frame F. Return in *PROP_IDX the index where tool-bar item
10247 properties start in F->tool_bar_items. Value is zero if
10248 GLYPH doesn't display a tool-bar item. */
10251 tool_bar_item_info (f
, glyph
, prop_idx
)
10253 struct glyph
*glyph
;
10260 /* This function can be called asynchronously, which means we must
10261 exclude any possibility that Fget_text_property signals an
10263 charpos
= min (SCHARS (f
->current_tool_bar_string
), glyph
->charpos
);
10264 charpos
= max (0, charpos
);
10266 /* Get the text property `menu-item' at pos. The value of that
10267 property is the start index of this item's properties in
10268 F->tool_bar_items. */
10269 prop
= Fget_text_property (make_number (charpos
),
10270 Qmenu_item
, f
->current_tool_bar_string
);
10271 if (INTEGERP (prop
))
10273 *prop_idx
= XINT (prop
);
10283 /* Get information about the tool-bar item at position X/Y on frame F.
10284 Return in *GLYPH a pointer to the glyph of the tool-bar item in
10285 the current matrix of the tool-bar window of F, or NULL if not
10286 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
10287 item in F->tool_bar_items. Value is
10289 -1 if X/Y is not on a tool-bar item
10290 0 if X/Y is on the same item that was highlighted before.
10294 get_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
10297 struct glyph
**glyph
;
10298 int *hpos
, *vpos
, *prop_idx
;
10300 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10301 struct window
*w
= XWINDOW (f
->tool_bar_window
);
10304 /* Find the glyph under X/Y. */
10305 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, 0, 0, &area
);
10306 if (*glyph
== NULL
)
10309 /* Get the start of this tool-bar item's properties in
10310 f->tool_bar_items. */
10311 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
10314 /* Is mouse on the highlighted item? */
10315 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
10316 && *vpos
>= dpyinfo
->mouse_face_beg_row
10317 && *vpos
<= dpyinfo
->mouse_face_end_row
10318 && (*vpos
> dpyinfo
->mouse_face_beg_row
10319 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
10320 && (*vpos
< dpyinfo
->mouse_face_end_row
10321 || *hpos
< dpyinfo
->mouse_face_end_col
10322 || dpyinfo
->mouse_face_past_end
))
10330 Handle mouse button event on the tool-bar of frame F, at
10331 frame-relative coordinates X/Y. DOWN_P is 1 for a button press,
10332 0 for button release. MODIFIERS is event modifiers for button
10336 handle_tool_bar_click (f
, x
, y
, down_p
, modifiers
)
10339 unsigned int modifiers
;
10341 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10342 struct window
*w
= XWINDOW (f
->tool_bar_window
);
10343 int hpos
, vpos
, prop_idx
;
10344 struct glyph
*glyph
;
10345 Lisp_Object enabled_p
;
10347 /* If not on the highlighted tool-bar item, return. */
10348 frame_to_window_pixel_xy (w
, &x
, &y
);
10349 if (get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
10352 /* If item is disabled, do nothing. */
10353 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
10354 if (NILP (enabled_p
))
10359 /* Show item in pressed state. */
10360 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
10361 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
10362 last_tool_bar_item
= prop_idx
;
10366 Lisp_Object key
, frame
;
10367 struct input_event event
;
10368 EVENT_INIT (event
);
10370 /* Show item in released state. */
10371 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
10372 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
10374 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
10376 XSETFRAME (frame
, f
);
10377 event
.kind
= TOOL_BAR_EVENT
;
10378 event
.frame_or_window
= frame
;
10380 kbd_buffer_store_event (&event
);
10382 event
.kind
= TOOL_BAR_EVENT
;
10383 event
.frame_or_window
= frame
;
10385 event
.modifiers
= modifiers
;
10386 kbd_buffer_store_event (&event
);
10387 last_tool_bar_item
= -1;
10392 /* Possibly highlight a tool-bar item on frame F when mouse moves to
10393 tool-bar window-relative coordinates X/Y. Called from
10394 note_mouse_highlight. */
10397 note_tool_bar_highlight (f
, x
, y
)
10401 Lisp_Object window
= f
->tool_bar_window
;
10402 struct window
*w
= XWINDOW (window
);
10403 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10405 struct glyph
*glyph
;
10406 struct glyph_row
*row
;
10408 Lisp_Object enabled_p
;
10410 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
10411 int mouse_down_p
, rc
;
10413 /* Function note_mouse_highlight is called with negative x(y
10414 values when mouse moves outside of the frame. */
10415 if (x
<= 0 || y
<= 0)
10417 clear_mouse_face (dpyinfo
);
10421 rc
= get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
10424 /* Not on tool-bar item. */
10425 clear_mouse_face (dpyinfo
);
10429 /* On same tool-bar item as before. */
10430 goto set_help_echo
;
10432 clear_mouse_face (dpyinfo
);
10434 /* Mouse is down, but on different tool-bar item? */
10435 mouse_down_p
= (dpyinfo
->grabbed
10436 && f
== last_mouse_frame
10437 && FRAME_LIVE_P (f
));
10439 && last_tool_bar_item
!= prop_idx
)
10442 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
10443 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
10445 /* If tool-bar item is not enabled, don't highlight it. */
10446 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
10447 if (!NILP (enabled_p
))
10449 /* Compute the x-position of the glyph. In front and past the
10450 image is a space. We include this in the highlighted area. */
10451 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
10452 for (i
= x
= 0; i
< hpos
; ++i
)
10453 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
10455 /* Record this as the current active region. */
10456 dpyinfo
->mouse_face_beg_col
= hpos
;
10457 dpyinfo
->mouse_face_beg_row
= vpos
;
10458 dpyinfo
->mouse_face_beg_x
= x
;
10459 dpyinfo
->mouse_face_beg_y
= row
->y
;
10460 dpyinfo
->mouse_face_past_end
= 0;
10462 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
10463 dpyinfo
->mouse_face_end_row
= vpos
;
10464 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
10465 dpyinfo
->mouse_face_end_y
= row
->y
;
10466 dpyinfo
->mouse_face_window
= window
;
10467 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
10469 /* Display it as active. */
10470 show_mouse_face (dpyinfo
, draw
);
10471 dpyinfo
->mouse_face_image_state
= draw
;
10476 /* Set help_echo_string to a help string to display for this tool-bar item.
10477 XTread_socket does the rest. */
10478 help_echo_object
= help_echo_window
= Qnil
;
10479 help_echo_pos
= -1;
10480 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
10481 if (NILP (help_echo_string
))
10482 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
10485 #endif /* HAVE_WINDOW_SYSTEM */
10489 /************************************************************************
10490 Horizontal scrolling
10491 ************************************************************************/
10493 static int hscroll_window_tree
P_ ((Lisp_Object
));
10494 static int hscroll_windows
P_ ((Lisp_Object
));
10496 /* For all leaf windows in the window tree rooted at WINDOW, set their
10497 hscroll value so that PT is (i) visible in the window, and (ii) so
10498 that it is not within a certain margin at the window's left and
10499 right border. Value is non-zero if any window's hscroll has been
10503 hscroll_window_tree (window
)
10504 Lisp_Object window
;
10506 int hscrolled_p
= 0;
10507 int hscroll_relative_p
= FLOATP (Vhscroll_step
);
10508 int hscroll_step_abs
= 0;
10509 double hscroll_step_rel
= 0;
10511 if (hscroll_relative_p
)
10513 hscroll_step_rel
= XFLOAT_DATA (Vhscroll_step
);
10514 if (hscroll_step_rel
< 0)
10516 hscroll_relative_p
= 0;
10517 hscroll_step_abs
= 0;
10520 else if (INTEGERP (Vhscroll_step
))
10522 hscroll_step_abs
= XINT (Vhscroll_step
);
10523 if (hscroll_step_abs
< 0)
10524 hscroll_step_abs
= 0;
10527 hscroll_step_abs
= 0;
10529 while (WINDOWP (window
))
10531 struct window
*w
= XWINDOW (window
);
10533 if (WINDOWP (w
->hchild
))
10534 hscrolled_p
|= hscroll_window_tree (w
->hchild
);
10535 else if (WINDOWP (w
->vchild
))
10536 hscrolled_p
|= hscroll_window_tree (w
->vchild
);
10537 else if (w
->cursor
.vpos
>= 0)
10540 int text_area_width
;
10541 struct glyph_row
*current_cursor_row
10542 = MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
10543 struct glyph_row
*desired_cursor_row
10544 = MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
);
10545 struct glyph_row
*cursor_row
10546 = (desired_cursor_row
->enabled_p
10547 ? desired_cursor_row
10548 : current_cursor_row
);
10550 text_area_width
= window_box_width (w
, TEXT_AREA
);
10552 /* Scroll when cursor is inside this scroll margin. */
10553 h_margin
= hscroll_margin
* WINDOW_FRAME_COLUMN_WIDTH (w
);
10555 if ((XFASTINT (w
->hscroll
)
10556 && w
->cursor
.x
<= h_margin
)
10557 || (cursor_row
->enabled_p
10558 && cursor_row
->truncated_on_right_p
10559 && (w
->cursor
.x
>= text_area_width
- h_margin
)))
10563 struct buffer
*saved_current_buffer
;
10567 /* Find point in a display of infinite width. */
10568 saved_current_buffer
= current_buffer
;
10569 current_buffer
= XBUFFER (w
->buffer
);
10571 if (w
== XWINDOW (selected_window
))
10572 pt
= BUF_PT (current_buffer
);
10575 pt
= marker_position (w
->pointm
);
10576 pt
= max (BEGV
, pt
);
10580 /* Move iterator to pt starting at cursor_row->start in
10581 a line with infinite width. */
10582 init_to_row_start (&it
, w
, cursor_row
);
10583 it
.last_visible_x
= INFINITY
;
10584 move_it_in_display_line_to (&it
, pt
, -1, MOVE_TO_POS
);
10585 current_buffer
= saved_current_buffer
;
10587 /* Position cursor in window. */
10588 if (!hscroll_relative_p
&& hscroll_step_abs
== 0)
10589 hscroll
= max (0, (it
.current_x
10590 - (ITERATOR_AT_END_OF_LINE_P (&it
)
10591 ? (text_area_width
- 4 * FRAME_COLUMN_WIDTH (it
.f
))
10592 : (text_area_width
/ 2))))
10593 / FRAME_COLUMN_WIDTH (it
.f
);
10594 else if (w
->cursor
.x
>= text_area_width
- h_margin
)
10596 if (hscroll_relative_p
)
10597 wanted_x
= text_area_width
* (1 - hscroll_step_rel
)
10600 wanted_x
= text_area_width
10601 - hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
10604 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
10608 if (hscroll_relative_p
)
10609 wanted_x
= text_area_width
* hscroll_step_rel
10612 wanted_x
= hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
10615 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
10617 hscroll
= max (hscroll
, XFASTINT (w
->min_hscroll
));
10619 /* Don't call Fset_window_hscroll if value hasn't
10620 changed because it will prevent redisplay
10622 if (XFASTINT (w
->hscroll
) != hscroll
)
10624 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
10625 w
->hscroll
= make_number (hscroll
);
10634 /* Value is non-zero if hscroll of any leaf window has been changed. */
10635 return hscrolled_p
;
10639 /* Set hscroll so that cursor is visible and not inside horizontal
10640 scroll margins for all windows in the tree rooted at WINDOW. See
10641 also hscroll_window_tree above. Value is non-zero if any window's
10642 hscroll has been changed. If it has, desired matrices on the frame
10643 of WINDOW are cleared. */
10646 hscroll_windows (window
)
10647 Lisp_Object window
;
10651 if (automatic_hscrolling_p
)
10653 hscrolled_p
= hscroll_window_tree (window
);
10655 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
10659 return hscrolled_p
;
10664 /************************************************************************
10666 ************************************************************************/
10668 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
10669 to a non-zero value. This is sometimes handy to have in a debugger
10674 /* First and last unchanged row for try_window_id. */
10676 int debug_first_unchanged_at_end_vpos
;
10677 int debug_last_unchanged_at_beg_vpos
;
10679 /* Delta vpos and y. */
10681 int debug_dvpos
, debug_dy
;
10683 /* Delta in characters and bytes for try_window_id. */
10685 int debug_delta
, debug_delta_bytes
;
10687 /* Values of window_end_pos and window_end_vpos at the end of
10690 EMACS_INT debug_end_pos
, debug_end_vpos
;
10692 /* Append a string to W->desired_matrix->method. FMT is a printf
10693 format string. A1...A9 are a supplement for a variable-length
10694 argument list. If trace_redisplay_p is non-zero also printf the
10695 resulting string to stderr. */
10698 debug_method_add (w
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
)
10701 int a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
;
10704 char *method
= w
->desired_matrix
->method
;
10705 int len
= strlen (method
);
10706 int size
= sizeof w
->desired_matrix
->method
;
10707 int remaining
= size
- len
- 1;
10709 sprintf (buffer
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
);
10710 if (len
&& remaining
)
10713 --remaining
, ++len
;
10716 strncpy (method
+ len
, buffer
, remaining
);
10718 if (trace_redisplay_p
)
10719 fprintf (stderr
, "%p (%s): %s\n",
10721 ((BUFFERP (w
->buffer
)
10722 && STRINGP (XBUFFER (w
->buffer
)->name
))
10723 ? (char *) SDATA (XBUFFER (w
->buffer
)->name
)
10728 #endif /* GLYPH_DEBUG */
10731 /* Value is non-zero if all changes in window W, which displays
10732 current_buffer, are in the text between START and END. START is a
10733 buffer position, END is given as a distance from Z. Used in
10734 redisplay_internal for display optimization. */
10737 text_outside_line_unchanged_p (w
, start
, end
)
10741 int unchanged_p
= 1;
10743 /* If text or overlays have changed, see where. */
10744 if (XFASTINT (w
->last_modified
) < MODIFF
10745 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
10747 /* Gap in the line? */
10748 if (GPT
< start
|| Z
- GPT
< end
)
10751 /* Changes start in front of the line, or end after it? */
10753 && (BEG_UNCHANGED
< start
- 1
10754 || END_UNCHANGED
< end
))
10757 /* If selective display, can't optimize if changes start at the
10758 beginning of the line. */
10760 && INTEGERP (current_buffer
->selective_display
)
10761 && XINT (current_buffer
->selective_display
) > 0
10762 && (BEG_UNCHANGED
< start
|| GPT
<= start
))
10765 /* If there are overlays at the start or end of the line, these
10766 may have overlay strings with newlines in them. A change at
10767 START, for instance, may actually concern the display of such
10768 overlay strings as well, and they are displayed on different
10769 lines. So, quickly rule out this case. (For the future, it
10770 might be desirable to implement something more telling than
10771 just BEG/END_UNCHANGED.) */
10774 if (BEG
+ BEG_UNCHANGED
== start
10775 && overlay_touches_p (start
))
10777 if (END_UNCHANGED
== end
10778 && overlay_touches_p (Z
- end
))
10783 return unchanged_p
;
10787 /* Do a frame update, taking possible shortcuts into account. This is
10788 the main external entry point for redisplay.
10790 If the last redisplay displayed an echo area message and that message
10791 is no longer requested, we clear the echo area or bring back the
10792 mini-buffer if that is in use. */
10797 redisplay_internal (0);
10802 overlay_arrow_string_or_property (var
)
10807 if (val
= Fget (var
, Qoverlay_arrow_string
), STRINGP (val
))
10810 return Voverlay_arrow_string
;
10813 /* Return 1 if there are any overlay-arrows in current_buffer. */
10815 overlay_arrow_in_current_buffer_p ()
10819 for (vlist
= Voverlay_arrow_variable_list
;
10821 vlist
= XCDR (vlist
))
10823 Lisp_Object var
= XCAR (vlist
);
10826 if (!SYMBOLP (var
))
10828 val
= find_symbol_value (var
);
10830 && current_buffer
== XMARKER (val
)->buffer
)
10837 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
10841 overlay_arrows_changed_p ()
10845 for (vlist
= Voverlay_arrow_variable_list
;
10847 vlist
= XCDR (vlist
))
10849 Lisp_Object var
= XCAR (vlist
);
10850 Lisp_Object val
, pstr
;
10852 if (!SYMBOLP (var
))
10854 val
= find_symbol_value (var
);
10855 if (!MARKERP (val
))
10857 if (! EQ (COERCE_MARKER (val
),
10858 Fget (var
, Qlast_arrow_position
))
10859 || ! (pstr
= overlay_arrow_string_or_property (var
),
10860 EQ (pstr
, Fget (var
, Qlast_arrow_string
))))
10866 /* Mark overlay arrows to be updated on next redisplay. */
10869 update_overlay_arrows (up_to_date
)
10874 for (vlist
= Voverlay_arrow_variable_list
;
10876 vlist
= XCDR (vlist
))
10878 Lisp_Object var
= XCAR (vlist
);
10880 if (!SYMBOLP (var
))
10883 if (up_to_date
> 0)
10885 Lisp_Object val
= find_symbol_value (var
);
10886 Fput (var
, Qlast_arrow_position
,
10887 COERCE_MARKER (val
));
10888 Fput (var
, Qlast_arrow_string
,
10889 overlay_arrow_string_or_property (var
));
10891 else if (up_to_date
< 0
10892 || !NILP (Fget (var
, Qlast_arrow_position
)))
10894 Fput (var
, Qlast_arrow_position
, Qt
);
10895 Fput (var
, Qlast_arrow_string
, Qt
);
10901 /* Return overlay arrow string to display at row.
10902 Return integer (bitmap number) for arrow bitmap in left fringe.
10903 Return nil if no overlay arrow. */
10906 overlay_arrow_at_row (it
, row
)
10908 struct glyph_row
*row
;
10912 for (vlist
= Voverlay_arrow_variable_list
;
10914 vlist
= XCDR (vlist
))
10916 Lisp_Object var
= XCAR (vlist
);
10919 if (!SYMBOLP (var
))
10922 val
= find_symbol_value (var
);
10925 && current_buffer
== XMARKER (val
)->buffer
10926 && (MATRIX_ROW_START_CHARPOS (row
) == marker_position (val
)))
10928 if (FRAME_WINDOW_P (it
->f
)
10929 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) > 0)
10931 #ifdef HAVE_WINDOW_SYSTEM
10932 if (val
= Fget (var
, Qoverlay_arrow_bitmap
), SYMBOLP (val
))
10935 if ((fringe_bitmap
= lookup_fringe_bitmap (val
)) != 0)
10936 return make_number (fringe_bitmap
);
10939 return make_number (-1); /* Use default arrow bitmap */
10941 return overlay_arrow_string_or_property (var
);
10948 /* Return 1 if point moved out of or into a composition. Otherwise
10949 return 0. PREV_BUF and PREV_PT are the last point buffer and
10950 position. BUF and PT are the current point buffer and position. */
10953 check_point_in_composition (prev_buf
, prev_pt
, buf
, pt
)
10954 struct buffer
*prev_buf
, *buf
;
10957 EMACS_INT start
, end
;
10959 Lisp_Object buffer
;
10961 XSETBUFFER (buffer
, buf
);
10962 /* Check a composition at the last point if point moved within the
10964 if (prev_buf
== buf
)
10967 /* Point didn't move. */
10970 if (prev_pt
> BUF_BEGV (buf
) && prev_pt
< BUF_ZV (buf
)
10971 && find_composition (prev_pt
, -1, &start
, &end
, &prop
, buffer
)
10972 && COMPOSITION_VALID_P (start
, end
, prop
)
10973 && start
< prev_pt
&& end
> prev_pt
)
10974 /* The last point was within the composition. Return 1 iff
10975 point moved out of the composition. */
10976 return (pt
<= start
|| pt
>= end
);
10979 /* Check a composition at the current point. */
10980 return (pt
> BUF_BEGV (buf
) && pt
< BUF_ZV (buf
)
10981 && find_composition (pt
, -1, &start
, &end
, &prop
, buffer
)
10982 && COMPOSITION_VALID_P (start
, end
, prop
)
10983 && start
< pt
&& end
> pt
);
10987 /* Reconsider the setting of B->clip_changed which is displayed
10991 reconsider_clip_changes (w
, b
)
10995 if (b
->clip_changed
10996 && !NILP (w
->window_end_valid
)
10997 && w
->current_matrix
->buffer
== b
10998 && w
->current_matrix
->zv
== BUF_ZV (b
)
10999 && w
->current_matrix
->begv
== BUF_BEGV (b
))
11000 b
->clip_changed
= 0;
11002 /* If display wasn't paused, and W is not a tool bar window, see if
11003 point has been moved into or out of a composition. In that case,
11004 we set b->clip_changed to 1 to force updating the screen. If
11005 b->clip_changed has already been set to 1, we can skip this
11007 if (!b
->clip_changed
11008 && BUFFERP (w
->buffer
) && !NILP (w
->window_end_valid
))
11012 if (w
== XWINDOW (selected_window
))
11013 pt
= BUF_PT (current_buffer
);
11015 pt
= marker_position (w
->pointm
);
11017 if ((w
->current_matrix
->buffer
!= XBUFFER (w
->buffer
)
11018 || pt
!= XINT (w
->last_point
))
11019 && check_point_in_composition (w
->current_matrix
->buffer
,
11020 XINT (w
->last_point
),
11021 XBUFFER (w
->buffer
), pt
))
11022 b
->clip_changed
= 1;
11027 /* Select FRAME to forward the values of frame-local variables into C
11028 variables so that the redisplay routines can access those values
11032 select_frame_for_redisplay (frame
)
11035 Lisp_Object tail
, sym
, val
;
11036 Lisp_Object old
= selected_frame
;
11038 xassert (FRAMEP (frame
) && FRAME_LIVE_P (XFRAME (frame
)));
11040 selected_frame
= frame
;
11042 for (tail
= XFRAME (frame
)->param_alist
; CONSP (tail
); tail
= XCDR (tail
))
11043 if (CONSP (XCAR (tail
))
11044 && (sym
= XCAR (XCAR (tail
)),
11046 && (sym
= indirect_variable (sym
),
11047 val
= SYMBOL_VALUE (sym
),
11048 (BUFFER_LOCAL_VALUEP (val
)))
11049 && XBUFFER_LOCAL_VALUE (val
)->check_frame
)
11050 /* Use find_symbol_value rather than Fsymbol_value
11051 to avoid an error if it is void. */
11052 find_symbol_value (sym
);
11054 for (tail
= XFRAME (old
)->param_alist
; CONSP (tail
); tail
= XCDR (tail
))
11055 if (CONSP (XCAR (tail
))
11056 && (sym
= XCAR (XCAR (tail
)),
11058 && (sym
= indirect_variable (sym
),
11059 val
= SYMBOL_VALUE (sym
),
11060 (BUFFER_LOCAL_VALUEP (val
)))
11061 && XBUFFER_LOCAL_VALUE (val
)->check_frame
)
11062 find_symbol_value (sym
);
11066 #define STOP_POLLING \
11067 do { if (! polling_stopped_here) stop_polling (); \
11068 polling_stopped_here = 1; } while (0)
11070 #define RESUME_POLLING \
11071 do { if (polling_stopped_here) start_polling (); \
11072 polling_stopped_here = 0; } while (0)
11075 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay is not in
11076 response to any user action; therefore, we should preserve the echo
11077 area. (Actually, our caller does that job.) Perhaps in the future
11078 avoid recentering windows if it is not necessary; currently that
11079 causes some problems. */
11082 redisplay_internal (preserve_echo_area
)
11083 int preserve_echo_area
;
11085 struct window
*w
= XWINDOW (selected_window
);
11088 int must_finish
= 0;
11089 struct text_pos tlbufpos
, tlendpos
;
11090 int number_of_visible_frames
;
11093 int polling_stopped_here
= 0;
11094 Lisp_Object old_frame
= selected_frame
;
11096 /* Non-zero means redisplay has to consider all windows on all
11097 frames. Zero means, only selected_window is considered. */
11098 int consider_all_windows_p
;
11100 TRACE ((stderr
, "redisplay_internal %d\n", redisplaying_p
));
11102 /* No redisplay if running in batch mode or frame is not yet fully
11103 initialized, or redisplay is explicitly turned off by setting
11104 Vinhibit_redisplay. */
11106 || !NILP (Vinhibit_redisplay
))
11109 /* Don't examine these until after testing Vinhibit_redisplay.
11110 When Emacs is shutting down, perhaps because its connection to
11111 X has dropped, we should not look at them at all. */
11112 f
= XFRAME (w
->frame
);
11113 sf
= SELECTED_FRAME ();
11115 if (!f
->glyphs_initialized_p
)
11118 /* The flag redisplay_performed_directly_p is set by
11119 direct_output_for_insert when it already did the whole screen
11120 update necessary. */
11121 if (redisplay_performed_directly_p
)
11123 redisplay_performed_directly_p
= 0;
11124 if (!hscroll_windows (selected_window
))
11128 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (MAC_OS)
11129 if (popup_activated ())
11133 /* I don't think this happens but let's be paranoid. */
11134 if (redisplaying_p
)
11137 /* Record a function that resets redisplaying_p to its old value
11138 when we leave this function. */
11139 count
= SPECPDL_INDEX ();
11140 record_unwind_protect (unwind_redisplay
,
11141 Fcons (make_number (redisplaying_p
), selected_frame
));
11143 specbind (Qinhibit_free_realized_faces
, Qnil
);
11146 Lisp_Object tail
, frame
;
11148 FOR_EACH_FRAME (tail
, frame
)
11150 struct frame
*f
= XFRAME (frame
);
11151 f
->already_hscrolled_p
= 0;
11156 if (!EQ (old_frame
, selected_frame
)
11157 && FRAME_LIVE_P (XFRAME (old_frame
)))
11158 /* When running redisplay, we play a bit fast-and-loose and allow e.g.
11159 selected_frame and selected_window to be temporarily out-of-sync so
11160 when we come back here via `goto retry', we need to resync because we
11161 may need to run Elisp code (via prepare_menu_bars). */
11162 select_frame_for_redisplay (old_frame
);
11165 reconsider_clip_changes (w
, current_buffer
);
11166 last_escape_glyph_frame
= NULL
;
11167 last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
11169 /* If new fonts have been loaded that make a glyph matrix adjustment
11170 necessary, do it. */
11171 if (fonts_changed_p
)
11173 adjust_glyphs (NULL
);
11174 ++windows_or_buffers_changed
;
11175 fonts_changed_p
= 0;
11178 /* If face_change_count is non-zero, init_iterator will free all
11179 realized faces, which includes the faces referenced from current
11180 matrices. So, we can't reuse current matrices in this case. */
11181 if (face_change_count
)
11182 ++windows_or_buffers_changed
;
11184 if (FRAME_TERMCAP_P (sf
)
11185 && FRAME_TTY (sf
)->previous_frame
!= sf
)
11187 /* Since frames on a single ASCII terminal share the same
11188 display area, displaying a different frame means redisplay
11189 the whole thing. */
11190 windows_or_buffers_changed
++;
11191 SET_FRAME_GARBAGED (sf
);
11192 FRAME_TTY (sf
)->previous_frame
= sf
;
11195 /* Set the visible flags for all frames. Do this before checking
11196 for resized or garbaged frames; they want to know if their frames
11197 are visible. See the comment in frame.h for
11198 FRAME_SAMPLE_VISIBILITY. */
11200 Lisp_Object tail
, frame
;
11202 number_of_visible_frames
= 0;
11204 FOR_EACH_FRAME (tail
, frame
)
11206 struct frame
*f
= XFRAME (frame
);
11208 FRAME_SAMPLE_VISIBILITY (f
);
11209 if (FRAME_VISIBLE_P (f
))
11210 ++number_of_visible_frames
;
11211 clear_desired_matrices (f
);
11216 /* Notice any pending interrupt request to change frame size. */
11217 do_pending_window_change (1);
11219 /* Clear frames marked as garbaged. */
11220 if (frame_garbaged
)
11221 clear_garbaged_frames ();
11223 /* Build menubar and tool-bar items. */
11224 if (NILP (Vmemory_full
))
11225 prepare_menu_bars ();
11227 if (windows_or_buffers_changed
)
11228 update_mode_lines
++;
11230 /* Detect case that we need to write or remove a star in the mode line. */
11231 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
11233 w
->update_mode_line
= Qt
;
11234 if (buffer_shared
> 1)
11235 update_mode_lines
++;
11238 /* Avoid invocation of point motion hooks by `current_column' below. */
11239 count1
= SPECPDL_INDEX ();
11240 specbind (Qinhibit_point_motion_hooks
, Qt
);
11242 /* If %c is in the mode line, update it if needed. */
11243 if (!NILP (w
->column_number_displayed
)
11244 /* This alternative quickly identifies a common case
11245 where no change is needed. */
11246 && !(PT
== XFASTINT (w
->last_point
)
11247 && XFASTINT (w
->last_modified
) >= MODIFF
11248 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
11249 && (XFASTINT (w
->column_number_displayed
)
11250 != (int) current_column ())) /* iftc */
11251 w
->update_mode_line
= Qt
;
11253 unbind_to (count1
, Qnil
);
11255 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
11257 /* The variable buffer_shared is set in redisplay_window and
11258 indicates that we redisplay a buffer in different windows. See
11260 consider_all_windows_p
= (update_mode_lines
|| buffer_shared
> 1
11261 || cursor_type_changed
);
11263 /* If specs for an arrow have changed, do thorough redisplay
11264 to ensure we remove any arrow that should no longer exist. */
11265 if (overlay_arrows_changed_p ())
11266 consider_all_windows_p
= windows_or_buffers_changed
= 1;
11268 /* Normally the message* functions will have already displayed and
11269 updated the echo area, but the frame may have been trashed, or
11270 the update may have been preempted, so display the echo area
11271 again here. Checking message_cleared_p captures the case that
11272 the echo area should be cleared. */
11273 if ((!NILP (echo_area_buffer
[0]) && !display_last_displayed_message_p
)
11274 || (!NILP (echo_area_buffer
[1]) && display_last_displayed_message_p
)
11275 || (message_cleared_p
11276 && minibuf_level
== 0
11277 /* If the mini-window is currently selected, this means the
11278 echo-area doesn't show through. */
11279 && !MINI_WINDOW_P (XWINDOW (selected_window
))))
11281 int window_height_changed_p
= echo_area_display (0);
11284 /* If we don't display the current message, don't clear the
11285 message_cleared_p flag, because, if we did, we wouldn't clear
11286 the echo area in the next redisplay which doesn't preserve
11288 if (!display_last_displayed_message_p
)
11289 message_cleared_p
= 0;
11291 if (fonts_changed_p
)
11293 else if (window_height_changed_p
)
11295 consider_all_windows_p
= 1;
11296 ++update_mode_lines
;
11297 ++windows_or_buffers_changed
;
11299 /* If window configuration was changed, frames may have been
11300 marked garbaged. Clear them or we will experience
11301 surprises wrt scrolling. */
11302 if (frame_garbaged
)
11303 clear_garbaged_frames ();
11306 else if (EQ (selected_window
, minibuf_window
)
11307 && (current_buffer
->clip_changed
11308 || XFASTINT (w
->last_modified
) < MODIFF
11309 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
11310 && resize_mini_window (w
, 0))
11312 /* Resized active mini-window to fit the size of what it is
11313 showing if its contents might have changed. */
11315 consider_all_windows_p
= 1;
11316 ++windows_or_buffers_changed
;
11317 ++update_mode_lines
;
11319 /* If window configuration was changed, frames may have been
11320 marked garbaged. Clear them or we will experience
11321 surprises wrt scrolling. */
11322 if (frame_garbaged
)
11323 clear_garbaged_frames ();
11327 /* If showing the region, and mark has changed, we must redisplay
11328 the whole window. The assignment to this_line_start_pos prevents
11329 the optimization directly below this if-statement. */
11330 if (((!NILP (Vtransient_mark_mode
)
11331 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
11332 != !NILP (w
->region_showing
))
11333 || (!NILP (w
->region_showing
)
11334 && !EQ (w
->region_showing
,
11335 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
11336 CHARPOS (this_line_start_pos
) = 0;
11338 /* Optimize the case that only the line containing the cursor in the
11339 selected window has changed. Variables starting with this_ are
11340 set in display_line and record information about the line
11341 containing the cursor. */
11342 tlbufpos
= this_line_start_pos
;
11343 tlendpos
= this_line_end_pos
;
11344 if (!consider_all_windows_p
11345 && CHARPOS (tlbufpos
) > 0
11346 && NILP (w
->update_mode_line
)
11347 && !current_buffer
->clip_changed
11348 && !current_buffer
->prevent_redisplay_optimizations_p
11349 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
11350 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
11351 /* Make sure recorded data applies to current buffer, etc. */
11352 && this_line_buffer
== current_buffer
11353 && current_buffer
== XBUFFER (w
->buffer
)
11354 && NILP (w
->force_start
)
11355 && NILP (w
->optional_new_start
)
11356 /* Point must be on the line that we have info recorded about. */
11357 && PT
>= CHARPOS (tlbufpos
)
11358 && PT
<= Z
- CHARPOS (tlendpos
)
11359 /* All text outside that line, including its final newline,
11360 must be unchanged */
11361 && text_outside_line_unchanged_p (w
, CHARPOS (tlbufpos
),
11362 CHARPOS (tlendpos
)))
11364 if (CHARPOS (tlbufpos
) > BEGV
11365 && FETCH_BYTE (BYTEPOS (tlbufpos
) - 1) != '\n'
11366 && (CHARPOS (tlbufpos
) == ZV
11367 || FETCH_BYTE (BYTEPOS (tlbufpos
)) == '\n'))
11368 /* Former continuation line has disappeared by becoming empty */
11370 else if (XFASTINT (w
->last_modified
) < MODIFF
11371 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
11372 || MINI_WINDOW_P (w
))
11374 /* We have to handle the case of continuation around a
11375 wide-column character (See the comment in indent.c around
11378 For instance, in the following case:
11380 -------- Insert --------
11381 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
11382 J_I_ ==> J_I_ `^^' are cursors.
11386 As we have to redraw the line above, we should goto cancel. */
11389 int line_height_before
= this_line_pixel_height
;
11391 /* Note that start_display will handle the case that the
11392 line starting at tlbufpos is a continuation lines. */
11393 start_display (&it
, w
, tlbufpos
);
11395 /* Implementation note: It this still necessary? */
11396 if (it
.current_x
!= this_line_start_x
)
11399 TRACE ((stderr
, "trying display optimization 1\n"));
11400 w
->cursor
.vpos
= -1;
11401 overlay_arrow_seen
= 0;
11402 it
.vpos
= this_line_vpos
;
11403 it
.current_y
= this_line_y
;
11404 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, this_line_vpos
);
11405 display_line (&it
);
11407 /* If line contains point, is not continued,
11408 and ends at same distance from eob as before, we win */
11409 if (w
->cursor
.vpos
>= 0
11410 /* Line is not continued, otherwise this_line_start_pos
11411 would have been set to 0 in display_line. */
11412 && CHARPOS (this_line_start_pos
)
11413 /* Line ends as before. */
11414 && CHARPOS (this_line_end_pos
) == CHARPOS (tlendpos
)
11415 /* Line has same height as before. Otherwise other lines
11416 would have to be shifted up or down. */
11417 && this_line_pixel_height
== line_height_before
)
11419 /* If this is not the window's last line, we must adjust
11420 the charstarts of the lines below. */
11421 if (it
.current_y
< it
.last_visible_y
)
11423 struct glyph_row
*row
11424 = MATRIX_ROW (w
->current_matrix
, this_line_vpos
+ 1);
11425 int delta
, delta_bytes
;
11427 if (Z
- CHARPOS (tlendpos
) == ZV
)
11429 /* This line ends at end of (accessible part of)
11430 buffer. There is no newline to count. */
11432 - CHARPOS (tlendpos
)
11433 - MATRIX_ROW_START_CHARPOS (row
));
11434 delta_bytes
= (Z_BYTE
11435 - BYTEPOS (tlendpos
)
11436 - MATRIX_ROW_START_BYTEPOS (row
));
11440 /* This line ends in a newline. Must take
11441 account of the newline and the rest of the
11442 text that follows. */
11444 - CHARPOS (tlendpos
)
11445 - MATRIX_ROW_START_CHARPOS (row
));
11446 delta_bytes
= (Z_BYTE
11447 - BYTEPOS (tlendpos
)
11448 - MATRIX_ROW_START_BYTEPOS (row
));
11451 increment_matrix_positions (w
->current_matrix
,
11452 this_line_vpos
+ 1,
11453 w
->current_matrix
->nrows
,
11454 delta
, delta_bytes
);
11457 /* If this row displays text now but previously didn't,
11458 or vice versa, w->window_end_vpos may have to be
11460 if ((it
.glyph_row
- 1)->displays_text_p
)
11462 if (XFASTINT (w
->window_end_vpos
) < this_line_vpos
)
11463 XSETINT (w
->window_end_vpos
, this_line_vpos
);
11465 else if (XFASTINT (w
->window_end_vpos
) == this_line_vpos
11466 && this_line_vpos
> 0)
11467 XSETINT (w
->window_end_vpos
, this_line_vpos
- 1);
11468 w
->window_end_valid
= Qnil
;
11470 /* Update hint: No need to try to scroll in update_window. */
11471 w
->desired_matrix
->no_scrolling_p
= 1;
11474 *w
->desired_matrix
->method
= 0;
11475 debug_method_add (w
, "optimization 1");
11477 #ifdef HAVE_WINDOW_SYSTEM
11478 update_window_fringes (w
, 0);
11485 else if (/* Cursor position hasn't changed. */
11486 PT
== XFASTINT (w
->last_point
)
11487 /* Make sure the cursor was last displayed
11488 in this window. Otherwise we have to reposition it. */
11489 && 0 <= w
->cursor
.vpos
11490 && WINDOW_TOTAL_LINES (w
) > w
->cursor
.vpos
)
11494 do_pending_window_change (1);
11496 /* We used to always goto end_of_redisplay here, but this
11497 isn't enough if we have a blinking cursor. */
11498 if (w
->cursor_off_p
== w
->last_cursor_off_p
)
11499 goto end_of_redisplay
;
11503 /* If highlighting the region, or if the cursor is in the echo area,
11504 then we can't just move the cursor. */
11505 else if (! (!NILP (Vtransient_mark_mode
)
11506 && !NILP (current_buffer
->mark_active
))
11507 && (EQ (selected_window
, current_buffer
->last_selected_window
)
11508 || highlight_nonselected_windows
)
11509 && NILP (w
->region_showing
)
11510 && NILP (Vshow_trailing_whitespace
)
11511 && !cursor_in_echo_area
)
11514 struct glyph_row
*row
;
11516 /* Skip from tlbufpos to PT and see where it is. Note that
11517 PT may be in invisible text. If so, we will end at the
11518 next visible position. */
11519 init_iterator (&it
, w
, CHARPOS (tlbufpos
), BYTEPOS (tlbufpos
),
11520 NULL
, DEFAULT_FACE_ID
);
11521 it
.current_x
= this_line_start_x
;
11522 it
.current_y
= this_line_y
;
11523 it
.vpos
= this_line_vpos
;
11525 /* The call to move_it_to stops in front of PT, but
11526 moves over before-strings. */
11527 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
11529 if (it
.vpos
== this_line_vpos
11530 && (row
= MATRIX_ROW (w
->current_matrix
, this_line_vpos
),
11533 xassert (this_line_vpos
== it
.vpos
);
11534 xassert (this_line_y
== it
.current_y
);
11535 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
11537 *w
->desired_matrix
->method
= 0;
11538 debug_method_add (w
, "optimization 3");
11547 /* Text changed drastically or point moved off of line. */
11548 SET_MATRIX_ROW_ENABLED_P (w
->desired_matrix
, this_line_vpos
, 0);
11551 CHARPOS (this_line_start_pos
) = 0;
11552 consider_all_windows_p
|= buffer_shared
> 1;
11553 ++clear_face_cache_count
;
11554 #ifdef HAVE_WINDOW_SYSTEM
11555 ++clear_image_cache_count
;
11558 /* Build desired matrices, and update the display. If
11559 consider_all_windows_p is non-zero, do it for all windows on all
11560 frames. Otherwise do it for selected_window, only. */
11562 if (consider_all_windows_p
)
11564 Lisp_Object tail
, frame
;
11566 FOR_EACH_FRAME (tail
, frame
)
11567 XFRAME (frame
)->updated_p
= 0;
11569 /* Recompute # windows showing selected buffer. This will be
11570 incremented each time such a window is displayed. */
11573 FOR_EACH_FRAME (tail
, frame
)
11575 struct frame
*f
= XFRAME (frame
);
11577 if (FRAME_WINDOW_P (f
) || FRAME_TERMCAP_P (f
) || f
== sf
)
11579 if (! EQ (frame
, selected_frame
))
11580 /* Select the frame, for the sake of frame-local
11582 select_frame_for_redisplay (frame
);
11584 /* Mark all the scroll bars to be removed; we'll redeem
11585 the ones we want when we redisplay their windows. */
11586 if (FRAME_TERMINAL (f
)->condemn_scroll_bars_hook
)
11587 FRAME_TERMINAL (f
)->condemn_scroll_bars_hook (f
);
11589 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
11590 redisplay_windows (FRAME_ROOT_WINDOW (f
));
11592 /* Any scroll bars which redisplay_windows should have
11593 nuked should now go away. */
11594 if (FRAME_TERMINAL (f
)->judge_scroll_bars_hook
)
11595 FRAME_TERMINAL (f
)->judge_scroll_bars_hook (f
);
11597 /* If fonts changed, display again. */
11598 /* ??? rms: I suspect it is a mistake to jump all the way
11599 back to retry here. It should just retry this frame. */
11600 if (fonts_changed_p
)
11603 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
11605 /* See if we have to hscroll. */
11606 if (!f
->already_hscrolled_p
)
11608 f
->already_hscrolled_p
= 1;
11609 if (hscroll_windows (f
->root_window
))
11613 /* Prevent various kinds of signals during display
11614 update. stdio is not robust about handling
11615 signals, which can cause an apparent I/O
11617 if (interrupt_input
)
11618 unrequest_sigio ();
11621 /* Update the display. */
11622 set_window_update_flags (XWINDOW (f
->root_window
), 1);
11623 pause
|= update_frame (f
, 0, 0);
11624 #if 0 /* Exiting the loop can leave the wrong value for buffer_shared. */
11636 /* Do the mark_window_display_accurate after all windows have
11637 been redisplayed because this call resets flags in buffers
11638 which are needed for proper redisplay. */
11639 FOR_EACH_FRAME (tail
, frame
)
11641 struct frame
*f
= XFRAME (frame
);
11644 mark_window_display_accurate (f
->root_window
, 1);
11645 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
11646 FRAME_TERMINAL (f
)->frame_up_to_date_hook (f
);
11651 else if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
11653 Lisp_Object mini_window
;
11654 struct frame
*mini_frame
;
11656 displayed_buffer
= XBUFFER (XWINDOW (selected_window
)->buffer
);
11657 /* Use list_of_error, not Qerror, so that
11658 we catch only errors and don't run the debugger. */
11659 internal_condition_case_1 (redisplay_window_1
, selected_window
,
11661 redisplay_window_error
);
11663 /* Compare desired and current matrices, perform output. */
11666 /* If fonts changed, display again. */
11667 if (fonts_changed_p
)
11670 /* Prevent various kinds of signals during display update.
11671 stdio is not robust about handling signals,
11672 which can cause an apparent I/O error. */
11673 if (interrupt_input
)
11674 unrequest_sigio ();
11677 if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
11679 if (hscroll_windows (selected_window
))
11682 XWINDOW (selected_window
)->must_be_updated_p
= 1;
11683 pause
= update_frame (sf
, 0, 0);
11686 /* We may have called echo_area_display at the top of this
11687 function. If the echo area is on another frame, that may
11688 have put text on a frame other than the selected one, so the
11689 above call to update_frame would not have caught it. Catch
11691 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
11692 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
11694 if (mini_frame
!= sf
&& FRAME_WINDOW_P (mini_frame
))
11696 XWINDOW (mini_window
)->must_be_updated_p
= 1;
11697 pause
|= update_frame (mini_frame
, 0, 0);
11698 if (!pause
&& hscroll_windows (mini_window
))
11703 /* If display was paused because of pending input, make sure we do a
11704 thorough update the next time. */
11707 /* Prevent the optimization at the beginning of
11708 redisplay_internal that tries a single-line update of the
11709 line containing the cursor in the selected window. */
11710 CHARPOS (this_line_start_pos
) = 0;
11712 /* Let the overlay arrow be updated the next time. */
11713 update_overlay_arrows (0);
11715 /* If we pause after scrolling, some rows in the current
11716 matrices of some windows are not valid. */
11717 if (!WINDOW_FULL_WIDTH_P (w
)
11718 && !FRAME_WINDOW_P (XFRAME (w
->frame
)))
11719 update_mode_lines
= 1;
11723 if (!consider_all_windows_p
)
11725 /* This has already been done above if
11726 consider_all_windows_p is set. */
11727 mark_window_display_accurate_1 (w
, 1);
11729 /* Say overlay arrows are up to date. */
11730 update_overlay_arrows (1);
11732 if (FRAME_TERMINAL (sf
)->frame_up_to_date_hook
!= 0)
11733 FRAME_TERMINAL (sf
)->frame_up_to_date_hook (sf
);
11736 update_mode_lines
= 0;
11737 windows_or_buffers_changed
= 0;
11738 cursor_type_changed
= 0;
11741 /* Start SIGIO interrupts coming again. Having them off during the
11742 code above makes it less likely one will discard output, but not
11743 impossible, since there might be stuff in the system buffer here.
11744 But it is much hairier to try to do anything about that. */
11745 if (interrupt_input
)
11749 /* If a frame has become visible which was not before, redisplay
11750 again, so that we display it. Expose events for such a frame
11751 (which it gets when becoming visible) don't call the parts of
11752 redisplay constructing glyphs, so simply exposing a frame won't
11753 display anything in this case. So, we have to display these
11754 frames here explicitly. */
11757 Lisp_Object tail
, frame
;
11760 FOR_EACH_FRAME (tail
, frame
)
11762 int this_is_visible
= 0;
11764 if (XFRAME (frame
)->visible
)
11765 this_is_visible
= 1;
11766 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
11767 if (XFRAME (frame
)->visible
)
11768 this_is_visible
= 1;
11770 if (this_is_visible
)
11774 if (new_count
!= number_of_visible_frames
)
11775 windows_or_buffers_changed
++;
11778 /* Change frame size now if a change is pending. */
11779 do_pending_window_change (1);
11781 /* If we just did a pending size change, or have additional
11782 visible frames, redisplay again. */
11783 if (windows_or_buffers_changed
&& !pause
)
11786 /* Clear the face cache eventually. */
11787 if (consider_all_windows_p
)
11789 if (clear_face_cache_count
> CLEAR_FACE_CACHE_COUNT
)
11791 clear_face_cache (0);
11792 clear_face_cache_count
= 0;
11794 #ifdef HAVE_WINDOW_SYSTEM
11795 if (clear_image_cache_count
> CLEAR_IMAGE_CACHE_COUNT
)
11797 Lisp_Object tail
, frame
;
11798 FOR_EACH_FRAME (tail
, frame
)
11800 struct frame
*f
= XFRAME (frame
);
11801 if (FRAME_WINDOW_P (f
))
11802 clear_image_cache (f
, 0);
11804 clear_image_cache_count
= 0;
11806 #endif /* HAVE_WINDOW_SYSTEM */
11810 unbind_to (count
, Qnil
);
11815 /* Redisplay, but leave alone any recent echo area message unless
11816 another message has been requested in its place.
11818 This is useful in situations where you need to redisplay but no
11819 user action has occurred, making it inappropriate for the message
11820 area to be cleared. See tracking_off and
11821 wait_reading_process_output for examples of these situations.
11823 FROM_WHERE is an integer saying from where this function was
11824 called. This is useful for debugging. */
11827 redisplay_preserve_echo_area (from_where
)
11830 TRACE ((stderr
, "redisplay_preserve_echo_area (%d)\n", from_where
));
11832 if (!NILP (echo_area_buffer
[1]))
11834 /* We have a previously displayed message, but no current
11835 message. Redisplay the previous message. */
11836 display_last_displayed_message_p
= 1;
11837 redisplay_internal (1);
11838 display_last_displayed_message_p
= 0;
11841 redisplay_internal (1);
11843 if (FRAME_RIF (SELECTED_FRAME ()) != NULL
11844 && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
11845 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL
);
11849 /* Function registered with record_unwind_protect in
11850 redisplay_internal. Reset redisplaying_p to the value it had
11851 before redisplay_internal was called, and clear
11852 prevent_freeing_realized_faces_p. It also selects the previously
11853 selected frame, unless it has been deleted (by an X connection
11854 failure during redisplay, for example). */
11857 unwind_redisplay (val
)
11860 Lisp_Object old_redisplaying_p
, old_frame
;
11862 old_redisplaying_p
= XCAR (val
);
11863 redisplaying_p
= XFASTINT (old_redisplaying_p
);
11864 old_frame
= XCDR (val
);
11865 if (! EQ (old_frame
, selected_frame
)
11866 && FRAME_LIVE_P (XFRAME (old_frame
)))
11867 select_frame_for_redisplay (old_frame
);
11872 /* Mark the display of window W as accurate or inaccurate. If
11873 ACCURATE_P is non-zero mark display of W as accurate. If
11874 ACCURATE_P is zero, arrange for W to be redisplayed the next time
11875 redisplay_internal is called. */
11878 mark_window_display_accurate_1 (w
, accurate_p
)
11882 if (BUFFERP (w
->buffer
))
11884 struct buffer
*b
= XBUFFER (w
->buffer
);
11887 = make_number (accurate_p
? BUF_MODIFF (b
) : 0);
11888 w
->last_overlay_modified
11889 = make_number (accurate_p
? BUF_OVERLAY_MODIFF (b
) : 0);
11891 = BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
) ? Qt
: Qnil
;
11895 b
->clip_changed
= 0;
11896 b
->prevent_redisplay_optimizations_p
= 0;
11898 BUF_UNCHANGED_MODIFIED (b
) = BUF_MODIFF (b
);
11899 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = BUF_OVERLAY_MODIFF (b
);
11900 BUF_BEG_UNCHANGED (b
) = BUF_GPT (b
) - BUF_BEG (b
);
11901 BUF_END_UNCHANGED (b
) = BUF_Z (b
) - BUF_GPT (b
);
11903 w
->current_matrix
->buffer
= b
;
11904 w
->current_matrix
->begv
= BUF_BEGV (b
);
11905 w
->current_matrix
->zv
= BUF_ZV (b
);
11907 w
->last_cursor
= w
->cursor
;
11908 w
->last_cursor_off_p
= w
->cursor_off_p
;
11910 if (w
== XWINDOW (selected_window
))
11911 w
->last_point
= make_number (BUF_PT (b
));
11913 w
->last_point
= make_number (XMARKER (w
->pointm
)->charpos
);
11919 w
->window_end_valid
= w
->buffer
;
11920 #if 0 /* This is incorrect with variable-height lines. */
11921 xassert (XINT (w
->window_end_vpos
)
11922 < (WINDOW_TOTAL_LINES (w
)
11923 - (WINDOW_WANTS_MODELINE_P (w
) ? 1 : 0)));
11925 w
->update_mode_line
= Qnil
;
11930 /* Mark the display of windows in the window tree rooted at WINDOW as
11931 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
11932 windows as accurate. If ACCURATE_P is zero, arrange for windows to
11933 be redisplayed the next time redisplay_internal is called. */
11936 mark_window_display_accurate (window
, accurate_p
)
11937 Lisp_Object window
;
11942 for (; !NILP (window
); window
= w
->next
)
11944 w
= XWINDOW (window
);
11945 mark_window_display_accurate_1 (w
, accurate_p
);
11947 if (!NILP (w
->vchild
))
11948 mark_window_display_accurate (w
->vchild
, accurate_p
);
11949 if (!NILP (w
->hchild
))
11950 mark_window_display_accurate (w
->hchild
, accurate_p
);
11955 update_overlay_arrows (1);
11959 /* Force a thorough redisplay the next time by setting
11960 last_arrow_position and last_arrow_string to t, which is
11961 unequal to any useful value of Voverlay_arrow_... */
11962 update_overlay_arrows (-1);
11967 /* Return value in display table DP (Lisp_Char_Table *) for character
11968 C. Since a display table doesn't have any parent, we don't have to
11969 follow parent. Do not call this function directly but use the
11970 macro DISP_CHAR_VECTOR. */
11973 disp_char_vector (dp
, c
)
11974 struct Lisp_Char_Table
*dp
;
11979 if (ASCII_CHAR_P (c
))
11982 if (SUB_CHAR_TABLE_P (val
))
11983 val
= XSUB_CHAR_TABLE (val
)->contents
[c
];
11989 XSETCHAR_TABLE (table
, dp
);
11990 val
= char_table_ref (table
, c
);
11999 /***********************************************************************
12001 ***********************************************************************/
12003 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
12006 redisplay_windows (window
)
12007 Lisp_Object window
;
12009 while (!NILP (window
))
12011 struct window
*w
= XWINDOW (window
);
12013 if (!NILP (w
->hchild
))
12014 redisplay_windows (w
->hchild
);
12015 else if (!NILP (w
->vchild
))
12016 redisplay_windows (w
->vchild
);
12019 displayed_buffer
= XBUFFER (w
->buffer
);
12020 /* Use list_of_error, not Qerror, so that
12021 we catch only errors and don't run the debugger. */
12022 internal_condition_case_1 (redisplay_window_0
, window
,
12024 redisplay_window_error
);
12032 redisplay_window_error ()
12034 displayed_buffer
->display_error_modiff
= BUF_MODIFF (displayed_buffer
);
12039 redisplay_window_0 (window
)
12040 Lisp_Object window
;
12042 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
12043 redisplay_window (window
, 0);
12048 redisplay_window_1 (window
)
12049 Lisp_Object window
;
12051 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
12052 redisplay_window (window
, 1);
12057 /* Increment GLYPH until it reaches END or CONDITION fails while
12058 adding (GLYPH)->pixel_width to X. */
12060 #define SKIP_GLYPHS(glyph, end, x, condition) \
12063 (x) += (glyph)->pixel_width; \
12066 while ((glyph) < (end) && (condition))
12069 /* Set cursor position of W. PT is assumed to be displayed in ROW.
12070 DELTA is the number of bytes by which positions recorded in ROW
12071 differ from current buffer positions.
12073 Return 0 if cursor is not on this row. 1 otherwise. */
12076 set_cursor_from_row (w
, row
, matrix
, delta
, delta_bytes
, dy
, dvpos
)
12078 struct glyph_row
*row
;
12079 struct glyph_matrix
*matrix
;
12080 int delta
, delta_bytes
, dy
, dvpos
;
12082 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
12083 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
12084 struct glyph
*cursor
= NULL
;
12085 /* The first glyph that starts a sequence of glyphs from string. */
12086 struct glyph
*string_start
;
12087 /* The X coordinate of string_start. */
12088 int string_start_x
;
12089 /* The last known character position. */
12090 int last_pos
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
12091 /* The last known character position before string_start. */
12092 int string_before_pos
;
12095 int cursor_from_overlay_pos
= 0;
12096 int pt_old
= PT
- delta
;
12098 /* Skip over glyphs not having an object at the start of the row.
12099 These are special glyphs like truncation marks on terminal
12101 if (row
->displays_text_p
)
12103 && INTEGERP (glyph
->object
)
12104 && glyph
->charpos
< 0)
12106 x
+= glyph
->pixel_width
;
12110 string_start
= NULL
;
12112 && !INTEGERP (glyph
->object
)
12113 && (!BUFFERP (glyph
->object
)
12114 || (last_pos
= glyph
->charpos
) < pt_old
))
12116 if (! STRINGP (glyph
->object
))
12118 string_start
= NULL
;
12119 x
+= glyph
->pixel_width
;
12121 if (cursor_from_overlay_pos
12122 && last_pos
>= cursor_from_overlay_pos
)
12124 cursor_from_overlay_pos
= 0;
12130 if (string_start
== NULL
)
12132 string_before_pos
= last_pos
;
12133 string_start
= glyph
;
12134 string_start_x
= x
;
12136 /* Skip all glyphs from string. */
12141 if ((cursor
== NULL
|| glyph
> cursor
)
12142 && (cprop
= Fget_char_property (make_number ((glyph
)->charpos
),
12143 Qcursor
, (glyph
)->object
),
12145 && (pos
= string_buffer_position (w
, glyph
->object
,
12146 string_before_pos
),
12147 (pos
== 0 /* From overlay */
12148 || pos
== pt_old
)))
12150 /* Estimate overlay buffer position from the buffer
12151 positions of the glyphs before and after the overlay.
12152 Add 1 to last_pos so that if point corresponds to the
12153 glyph right after the overlay, we still use a 'cursor'
12154 property found in that overlay. */
12155 cursor_from_overlay_pos
= (pos
? 0 : last_pos
12156 + (INTEGERP (cprop
) ? XINT (cprop
) : 0));
12160 x
+= glyph
->pixel_width
;
12163 while (glyph
< end
&& EQ (glyph
->object
, string_start
->object
));
12167 if (cursor
!= NULL
)
12172 else if (row
->ends_in_ellipsis_p
&& glyph
== end
)
12174 /* Scan back over the ellipsis glyphs, decrementing positions. */
12175 while (glyph
> row
->glyphs
[TEXT_AREA
]
12176 && (glyph
- 1)->charpos
== last_pos
)
12177 glyph
--, x
-= glyph
->pixel_width
;
12178 /* That loop always goes one position too far,
12179 including the glyph before the ellipsis.
12180 So scan forward over that one. */
12181 x
+= glyph
->pixel_width
;
12184 else if (string_start
12185 && (glyph
== end
|| !BUFFERP (glyph
->object
) || last_pos
> pt_old
))
12187 /* We may have skipped over point because the previous glyphs
12188 are from string. As there's no easy way to know the
12189 character position of the current glyph, find the correct
12190 glyph on point by scanning from string_start again. */
12192 Lisp_Object string
;
12193 struct glyph
*stop
= glyph
;
12196 limit
= make_number (pt_old
+ 1);
12197 glyph
= string_start
;
12198 x
= string_start_x
;
12199 string
= glyph
->object
;
12200 pos
= string_buffer_position (w
, string
, string_before_pos
);
12201 /* If STRING is from overlay, LAST_POS == 0. We skip such glyphs
12202 because we always put cursor after overlay strings. */
12203 while (pos
== 0 && glyph
< stop
)
12205 string
= glyph
->object
;
12206 SKIP_GLYPHS (glyph
, stop
, x
, EQ (glyph
->object
, string
));
12208 pos
= string_buffer_position (w
, glyph
->object
, string_before_pos
);
12211 while (glyph
< stop
)
12213 pos
= XINT (Fnext_single_char_property_change
12214 (make_number (pos
), Qdisplay
, Qnil
, limit
));
12217 /* Skip glyphs from the same string. */
12218 string
= glyph
->object
;
12219 SKIP_GLYPHS (glyph
, stop
, x
, EQ (glyph
->object
, string
));
12220 /* Skip glyphs from an overlay. */
12221 while (glyph
< stop
12222 && ! string_buffer_position (w
, glyph
->object
, pos
))
12224 string
= glyph
->object
;
12225 SKIP_GLYPHS (glyph
, stop
, x
, EQ (glyph
->object
, string
));
12229 /* If we reached the end of the line, and end was from a string,
12230 cursor is not on this line. */
12231 if (glyph
== end
&& row
->continued_p
)
12235 w
->cursor
.hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
12237 w
->cursor
.vpos
= MATRIX_ROW_VPOS (row
, matrix
) + dvpos
;
12238 w
->cursor
.y
= row
->y
+ dy
;
12240 if (w
== XWINDOW (selected_window
))
12242 if (!row
->continued_p
12243 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
12246 this_line_buffer
= XBUFFER (w
->buffer
);
12248 CHARPOS (this_line_start_pos
)
12249 = MATRIX_ROW_START_CHARPOS (row
) + delta
;
12250 BYTEPOS (this_line_start_pos
)
12251 = MATRIX_ROW_START_BYTEPOS (row
) + delta_bytes
;
12253 CHARPOS (this_line_end_pos
)
12254 = Z
- (MATRIX_ROW_END_CHARPOS (row
) + delta
);
12255 BYTEPOS (this_line_end_pos
)
12256 = Z_BYTE
- (MATRIX_ROW_END_BYTEPOS (row
) + delta_bytes
);
12258 this_line_y
= w
->cursor
.y
;
12259 this_line_pixel_height
= row
->height
;
12260 this_line_vpos
= w
->cursor
.vpos
;
12261 this_line_start_x
= row
->x
;
12264 CHARPOS (this_line_start_pos
) = 0;
12271 /* Run window scroll functions, if any, for WINDOW with new window
12272 start STARTP. Sets the window start of WINDOW to that position.
12274 We assume that the window's buffer is really current. */
12276 static INLINE
struct text_pos
12277 run_window_scroll_functions (window
, startp
)
12278 Lisp_Object window
;
12279 struct text_pos startp
;
12281 struct window
*w
= XWINDOW (window
);
12282 SET_MARKER_FROM_TEXT_POS (w
->start
, startp
);
12284 if (current_buffer
!= XBUFFER (w
->buffer
))
12287 if (!NILP (Vwindow_scroll_functions
))
12289 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
12290 make_number (CHARPOS (startp
)));
12291 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
12292 /* In case the hook functions switch buffers. */
12293 if (current_buffer
!= XBUFFER (w
->buffer
))
12294 set_buffer_internal_1 (XBUFFER (w
->buffer
));
12301 /* Make sure the line containing the cursor is fully visible.
12302 A value of 1 means there is nothing to be done.
12303 (Either the line is fully visible, or it cannot be made so,
12304 or we cannot tell.)
12306 If FORCE_P is non-zero, return 0 even if partial visible cursor row
12307 is higher than window.
12309 A value of 0 means the caller should do scrolling
12310 as if point had gone off the screen. */
12313 cursor_row_fully_visible_p (w
, force_p
, current_matrix_p
)
12316 int current_matrix_p
;
12318 struct glyph_matrix
*matrix
;
12319 struct glyph_row
*row
;
12322 if (!make_cursor_line_fully_visible_p
)
12325 /* It's not always possible to find the cursor, e.g, when a window
12326 is full of overlay strings. Don't do anything in that case. */
12327 if (w
->cursor
.vpos
< 0)
12330 matrix
= current_matrix_p
? w
->current_matrix
: w
->desired_matrix
;
12331 row
= MATRIX_ROW (matrix
, w
->cursor
.vpos
);
12333 /* If the cursor row is not partially visible, there's nothing to do. */
12334 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
))
12337 /* If the row the cursor is in is taller than the window's height,
12338 it's not clear what to do, so do nothing. */
12339 window_height
= window_box_height (w
);
12340 if (row
->height
>= window_height
)
12342 if (!force_p
|| MINI_WINDOW_P (w
)
12343 || w
->vscroll
|| w
->cursor
.vpos
== 0)
12349 /* This code used to try to scroll the window just enough to make
12350 the line visible. It returned 0 to say that the caller should
12351 allocate larger glyph matrices. */
12353 if (MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
12355 int dy
= row
->height
- row
->visible_height
;
12358 shift_glyph_matrix (w
, matrix
, 0, matrix
->nrows
, dy
);
12360 else /* MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row)) */
12362 int dy
= - (row
->height
- row
->visible_height
);
12365 shift_glyph_matrix (w
, matrix
, 0, matrix
->nrows
, dy
);
12368 /* When we change the cursor y-position of the selected window,
12369 change this_line_y as well so that the display optimization for
12370 the cursor line of the selected window in redisplay_internal uses
12371 the correct y-position. */
12372 if (w
== XWINDOW (selected_window
))
12373 this_line_y
= w
->cursor
.y
;
12375 /* If vscrolling requires a larger glyph matrix, arrange for a fresh
12376 redisplay with larger matrices. */
12377 if (matrix
->nrows
< required_matrix_height (w
))
12379 fonts_changed_p
= 1;
12388 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
12389 non-zero means only WINDOW is redisplayed in redisplay_internal.
12390 TEMP_SCROLL_STEP has the same meaning as scroll_step, and is used
12391 in redisplay_window to bring a partially visible line into view in
12392 the case that only the cursor has moved.
12394 LAST_LINE_MISFIT should be nonzero if we're scrolling because the
12395 last screen line's vertical height extends past the end of the screen.
12399 1 if scrolling succeeded
12401 0 if scrolling didn't find point.
12403 -1 if new fonts have been loaded so that we must interrupt
12404 redisplay, adjust glyph matrices, and try again. */
12410 SCROLLING_NEED_LARGER_MATRICES
12414 try_scrolling (window
, just_this_one_p
, scroll_conservatively
,
12415 scroll_step
, temp_scroll_step
, last_line_misfit
)
12416 Lisp_Object window
;
12417 int just_this_one_p
;
12418 EMACS_INT scroll_conservatively
, scroll_step
;
12419 int temp_scroll_step
;
12420 int last_line_misfit
;
12422 struct window
*w
= XWINDOW (window
);
12423 struct frame
*f
= XFRAME (w
->frame
);
12424 struct text_pos scroll_margin_pos
;
12425 struct text_pos pos
;
12426 struct text_pos startp
;
12428 Lisp_Object window_end
;
12429 int this_scroll_margin
;
12433 int amount_to_scroll
= 0;
12434 Lisp_Object aggressive
;
12436 int extra_scroll_margin_lines
= last_line_misfit
? 1 : 0;
12439 debug_method_add (w
, "try_scrolling");
12442 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
12444 /* Compute scroll margin height in pixels. We scroll when point is
12445 within this distance from the top or bottom of the window. */
12446 if (scroll_margin
> 0)
12448 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
12449 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
12452 this_scroll_margin
= 0;
12454 /* Force scroll_conservatively to have a reasonable value so it doesn't
12455 cause an overflow while computing how much to scroll. */
12456 if (scroll_conservatively
)
12457 scroll_conservatively
= min (scroll_conservatively
,
12458 MOST_POSITIVE_FIXNUM
/ FRAME_LINE_HEIGHT (f
));
12460 /* Compute how much we should try to scroll maximally to bring point
12462 if (scroll_step
|| scroll_conservatively
|| temp_scroll_step
)
12463 scroll_max
= max (scroll_step
,
12464 max (scroll_conservatively
, temp_scroll_step
));
12465 else if (NUMBERP (current_buffer
->scroll_down_aggressively
)
12466 || NUMBERP (current_buffer
->scroll_up_aggressively
))
12467 /* We're trying to scroll because of aggressive scrolling
12468 but no scroll_step is set. Choose an arbitrary one. Maybe
12469 there should be a variable for this. */
12473 scroll_max
*= FRAME_LINE_HEIGHT (f
);
12475 /* Decide whether we have to scroll down. Start at the window end
12476 and move this_scroll_margin up to find the position of the scroll
12478 window_end
= Fwindow_end (window
, Qt
);
12482 CHARPOS (scroll_margin_pos
) = XINT (window_end
);
12483 BYTEPOS (scroll_margin_pos
) = CHAR_TO_BYTE (CHARPOS (scroll_margin_pos
));
12485 if (this_scroll_margin
|| extra_scroll_margin_lines
)
12487 start_display (&it
, w
, scroll_margin_pos
);
12488 if (this_scroll_margin
)
12489 move_it_vertically_backward (&it
, this_scroll_margin
);
12490 if (extra_scroll_margin_lines
)
12491 move_it_by_lines (&it
, - extra_scroll_margin_lines
, 0);
12492 scroll_margin_pos
= it
.current
.pos
;
12495 if (PT
>= CHARPOS (scroll_margin_pos
))
12499 /* Point is in the scroll margin at the bottom of the window, or
12500 below. Compute a new window start that makes point visible. */
12502 /* Compute the distance from the scroll margin to PT.
12503 Give up if the distance is greater than scroll_max. */
12504 start_display (&it
, w
, scroll_margin_pos
);
12506 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
12507 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
12509 /* To make point visible, we have to move the window start
12510 down so that the line the cursor is in is visible, which
12511 means we have to add in the height of the cursor line. */
12512 dy
= line_bottom_y (&it
) - y0
;
12514 if (dy
> scroll_max
)
12515 return SCROLLING_FAILED
;
12517 /* Move the window start down. If scrolling conservatively,
12518 move it just enough down to make point visible. If
12519 scroll_step is set, move it down by scroll_step. */
12520 start_display (&it
, w
, startp
);
12522 if (scroll_conservatively
)
12523 /* Set AMOUNT_TO_SCROLL to at least one line,
12524 and at most scroll_conservatively lines. */
12526 = min (max (dy
, FRAME_LINE_HEIGHT (f
)),
12527 FRAME_LINE_HEIGHT (f
) * scroll_conservatively
);
12528 else if (scroll_step
|| temp_scroll_step
)
12529 amount_to_scroll
= scroll_max
;
12532 aggressive
= current_buffer
->scroll_up_aggressively
;
12533 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
12534 if (NUMBERP (aggressive
))
12536 double float_amount
= XFLOATINT (aggressive
) * height
;
12537 amount_to_scroll
= float_amount
;
12538 if (amount_to_scroll
== 0 && float_amount
> 0)
12539 amount_to_scroll
= 1;
12543 if (amount_to_scroll
<= 0)
12544 return SCROLLING_FAILED
;
12546 /* If moving by amount_to_scroll leaves STARTP unchanged,
12547 move it down one screen line. */
12549 move_it_vertically (&it
, amount_to_scroll
);
12550 if (CHARPOS (it
.current
.pos
) == CHARPOS (startp
))
12551 move_it_by_lines (&it
, 1, 1);
12552 startp
= it
.current
.pos
;
12556 /* See if point is inside the scroll margin at the top of the
12558 scroll_margin_pos
= startp
;
12559 if (this_scroll_margin
)
12561 start_display (&it
, w
, startp
);
12562 move_it_vertically (&it
, this_scroll_margin
);
12563 scroll_margin_pos
= it
.current
.pos
;
12566 if (PT
< CHARPOS (scroll_margin_pos
))
12568 /* Point is in the scroll margin at the top of the window or
12569 above what is displayed in the window. */
12572 /* Compute the vertical distance from PT to the scroll
12573 margin position. Give up if distance is greater than
12575 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
12576 start_display (&it
, w
, pos
);
12578 move_it_to (&it
, CHARPOS (scroll_margin_pos
), 0,
12579 it
.last_visible_y
, -1,
12580 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
12581 dy
= it
.current_y
- y0
;
12582 if (dy
> scroll_max
)
12583 return SCROLLING_FAILED
;
12585 /* Compute new window start. */
12586 start_display (&it
, w
, startp
);
12588 if (scroll_conservatively
)
12590 = max (dy
, FRAME_LINE_HEIGHT (f
) * max (scroll_step
, temp_scroll_step
));
12591 else if (scroll_step
|| temp_scroll_step
)
12592 amount_to_scroll
= scroll_max
;
12595 aggressive
= current_buffer
->scroll_down_aggressively
;
12596 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
12597 if (NUMBERP (aggressive
))
12599 double float_amount
= XFLOATINT (aggressive
) * height
;
12600 amount_to_scroll
= float_amount
;
12601 if (amount_to_scroll
== 0 && float_amount
> 0)
12602 amount_to_scroll
= 1;
12606 if (amount_to_scroll
<= 0)
12607 return SCROLLING_FAILED
;
12609 move_it_vertically_backward (&it
, amount_to_scroll
);
12610 startp
= it
.current
.pos
;
12614 /* Run window scroll functions. */
12615 startp
= run_window_scroll_functions (window
, startp
);
12617 /* Display the window. Give up if new fonts are loaded, or if point
12619 if (!try_window (window
, startp
, 0))
12620 rc
= SCROLLING_NEED_LARGER_MATRICES
;
12621 else if (w
->cursor
.vpos
< 0)
12623 clear_glyph_matrix (w
->desired_matrix
);
12624 rc
= SCROLLING_FAILED
;
12628 /* Maybe forget recorded base line for line number display. */
12629 if (!just_this_one_p
12630 || current_buffer
->clip_changed
12631 || BEG_UNCHANGED
< CHARPOS (startp
))
12632 w
->base_line_number
= Qnil
;
12634 /* If cursor ends up on a partially visible line,
12635 treat that as being off the bottom of the screen. */
12636 if (! cursor_row_fully_visible_p (w
, extra_scroll_margin_lines
<= 1, 0))
12638 clear_glyph_matrix (w
->desired_matrix
);
12639 ++extra_scroll_margin_lines
;
12642 rc
= SCROLLING_SUCCESS
;
12649 /* Compute a suitable window start for window W if display of W starts
12650 on a continuation line. Value is non-zero if a new window start
12653 The new window start will be computed, based on W's width, starting
12654 from the start of the continued line. It is the start of the
12655 screen line with the minimum distance from the old start W->start. */
12658 compute_window_start_on_continuation_line (w
)
12661 struct text_pos pos
, start_pos
;
12662 int window_start_changed_p
= 0;
12664 SET_TEXT_POS_FROM_MARKER (start_pos
, w
->start
);
12666 /* If window start is on a continuation line... Window start may be
12667 < BEGV in case there's invisible text at the start of the
12668 buffer (M-x rmail, for example). */
12669 if (CHARPOS (start_pos
) > BEGV
12670 && FETCH_BYTE (BYTEPOS (start_pos
) - 1) != '\n')
12673 struct glyph_row
*row
;
12675 /* Handle the case that the window start is out of range. */
12676 if (CHARPOS (start_pos
) < BEGV
)
12677 SET_TEXT_POS (start_pos
, BEGV
, BEGV_BYTE
);
12678 else if (CHARPOS (start_pos
) > ZV
)
12679 SET_TEXT_POS (start_pos
, ZV
, ZV_BYTE
);
12681 /* Find the start of the continued line. This should be fast
12682 because scan_buffer is fast (newline cache). */
12683 row
= w
->desired_matrix
->rows
+ (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0);
12684 init_iterator (&it
, w
, CHARPOS (start_pos
), BYTEPOS (start_pos
),
12685 row
, DEFAULT_FACE_ID
);
12686 reseat_at_previous_visible_line_start (&it
);
12688 /* If the line start is "too far" away from the window start,
12689 say it takes too much time to compute a new window start. */
12690 if (CHARPOS (start_pos
) - IT_CHARPOS (it
)
12691 < WINDOW_TOTAL_LINES (w
) * WINDOW_TOTAL_COLS (w
))
12693 int min_distance
, distance
;
12695 /* Move forward by display lines to find the new window
12696 start. If window width was enlarged, the new start can
12697 be expected to be > the old start. If window width was
12698 decreased, the new window start will be < the old start.
12699 So, we're looking for the display line start with the
12700 minimum distance from the old window start. */
12701 pos
= it
.current
.pos
;
12702 min_distance
= INFINITY
;
12703 while ((distance
= eabs (CHARPOS (start_pos
) - IT_CHARPOS (it
))),
12704 distance
< min_distance
)
12706 min_distance
= distance
;
12707 pos
= it
.current
.pos
;
12708 move_it_by_lines (&it
, 1, 0);
12711 /* Set the window start there. */
12712 SET_MARKER_FROM_TEXT_POS (w
->start
, pos
);
12713 window_start_changed_p
= 1;
12717 return window_start_changed_p
;
12721 /* Try cursor movement in case text has not changed in window WINDOW,
12722 with window start STARTP. Value is
12724 CURSOR_MOVEMENT_SUCCESS if successful
12726 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
12728 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
12729 display. *SCROLL_STEP is set to 1, under certain circumstances, if
12730 we want to scroll as if scroll-step were set to 1. See the code.
12732 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
12733 which case we have to abort this redisplay, and adjust matrices
12738 CURSOR_MOVEMENT_SUCCESS
,
12739 CURSOR_MOVEMENT_CANNOT_BE_USED
,
12740 CURSOR_MOVEMENT_MUST_SCROLL
,
12741 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
12745 try_cursor_movement (window
, startp
, scroll_step
)
12746 Lisp_Object window
;
12747 struct text_pos startp
;
12750 struct window
*w
= XWINDOW (window
);
12751 struct frame
*f
= XFRAME (w
->frame
);
12752 int rc
= CURSOR_MOVEMENT_CANNOT_BE_USED
;
12755 if (inhibit_try_cursor_movement
)
12759 /* Handle case where text has not changed, only point, and it has
12760 not moved off the frame. */
12761 if (/* Point may be in this window. */
12762 PT
>= CHARPOS (startp
)
12763 /* Selective display hasn't changed. */
12764 && !current_buffer
->clip_changed
12765 /* Function force-mode-line-update is used to force a thorough
12766 redisplay. It sets either windows_or_buffers_changed or
12767 update_mode_lines. So don't take a shortcut here for these
12769 && !update_mode_lines
12770 && !windows_or_buffers_changed
12771 && !cursor_type_changed
12772 /* Can't use this case if highlighting a region. When a
12773 region exists, cursor movement has to do more than just
12775 && !(!NILP (Vtransient_mark_mode
)
12776 && !NILP (current_buffer
->mark_active
))
12777 && NILP (w
->region_showing
)
12778 && NILP (Vshow_trailing_whitespace
)
12779 /* Right after splitting windows, last_point may be nil. */
12780 && INTEGERP (w
->last_point
)
12781 /* This code is not used for mini-buffer for the sake of the case
12782 of redisplaying to replace an echo area message; since in
12783 that case the mini-buffer contents per se are usually
12784 unchanged. This code is of no real use in the mini-buffer
12785 since the handling of this_line_start_pos, etc., in redisplay
12786 handles the same cases. */
12787 && !EQ (window
, minibuf_window
)
12788 /* When splitting windows or for new windows, it happens that
12789 redisplay is called with a nil window_end_vpos or one being
12790 larger than the window. This should really be fixed in
12791 window.c. I don't have this on my list, now, so we do
12792 approximately the same as the old redisplay code. --gerd. */
12793 && INTEGERP (w
->window_end_vpos
)
12794 && XFASTINT (w
->window_end_vpos
) < w
->current_matrix
->nrows
12795 && (FRAME_WINDOW_P (f
)
12796 || !overlay_arrow_in_current_buffer_p ()))
12798 int this_scroll_margin
, top_scroll_margin
;
12799 struct glyph_row
*row
= NULL
;
12802 debug_method_add (w
, "cursor movement");
12805 /* Scroll if point within this distance from the top or bottom
12806 of the window. This is a pixel value. */
12807 this_scroll_margin
= max (0, scroll_margin
);
12808 this_scroll_margin
= min (this_scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
12809 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
12811 top_scroll_margin
= this_scroll_margin
;
12812 if (WINDOW_WANTS_HEADER_LINE_P (w
))
12813 top_scroll_margin
+= CURRENT_HEADER_LINE_HEIGHT (w
);
12815 /* Start with the row the cursor was displayed during the last
12816 not paused redisplay. Give up if that row is not valid. */
12817 if (w
->last_cursor
.vpos
< 0
12818 || w
->last_cursor
.vpos
>= w
->current_matrix
->nrows
)
12819 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
12822 row
= MATRIX_ROW (w
->current_matrix
, w
->last_cursor
.vpos
);
12823 if (row
->mode_line_p
)
12825 if (!row
->enabled_p
)
12826 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
12829 if (rc
== CURSOR_MOVEMENT_CANNOT_BE_USED
)
12832 int last_y
= window_text_bottom_y (w
) - this_scroll_margin
;
12834 if (PT
> XFASTINT (w
->last_point
))
12836 /* Point has moved forward. */
12837 while (MATRIX_ROW_END_CHARPOS (row
) < PT
12838 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
12840 xassert (row
->enabled_p
);
12844 /* The end position of a row equals the start position
12845 of the next row. If PT is there, we would rather
12846 display it in the next line. */
12847 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
12848 && MATRIX_ROW_END_CHARPOS (row
) == PT
12849 && !cursor_row_p (w
, row
))
12852 /* If within the scroll margin, scroll. Note that
12853 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
12854 the next line would be drawn, and that
12855 this_scroll_margin can be zero. */
12856 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
12857 || PT
> MATRIX_ROW_END_CHARPOS (row
)
12858 /* Line is completely visible last line in window
12859 and PT is to be set in the next line. */
12860 || (MATRIX_ROW_BOTTOM_Y (row
) == last_y
12861 && PT
== MATRIX_ROW_END_CHARPOS (row
)
12862 && !row
->ends_at_zv_p
12863 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
12866 else if (PT
< XFASTINT (w
->last_point
))
12868 /* Cursor has to be moved backward. Note that PT >=
12869 CHARPOS (startp) because of the outer if-statement. */
12870 while (!row
->mode_line_p
12871 && (MATRIX_ROW_START_CHARPOS (row
) > PT
12872 || (MATRIX_ROW_START_CHARPOS (row
) == PT
12873 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row
)
12874 || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
12875 row
> w
->current_matrix
->rows
12876 && (row
-1)->ends_in_newline_from_string_p
))))
12877 && (row
->y
> top_scroll_margin
12878 || CHARPOS (startp
) == BEGV
))
12880 xassert (row
->enabled_p
);
12884 /* Consider the following case: Window starts at BEGV,
12885 there is invisible, intangible text at BEGV, so that
12886 display starts at some point START > BEGV. It can
12887 happen that we are called with PT somewhere between
12888 BEGV and START. Try to handle that case. */
12889 if (row
< w
->current_matrix
->rows
12890 || row
->mode_line_p
)
12892 row
= w
->current_matrix
->rows
;
12893 if (row
->mode_line_p
)
12897 /* Due to newlines in overlay strings, we may have to
12898 skip forward over overlay strings. */
12899 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
12900 && MATRIX_ROW_END_CHARPOS (row
) == PT
12901 && !cursor_row_p (w
, row
))
12904 /* If within the scroll margin, scroll. */
12905 if (row
->y
< top_scroll_margin
12906 && CHARPOS (startp
) != BEGV
)
12911 /* Cursor did not move. So don't scroll even if cursor line
12912 is partially visible, as it was so before. */
12913 rc
= CURSOR_MOVEMENT_SUCCESS
;
12916 if (PT
< MATRIX_ROW_START_CHARPOS (row
)
12917 || PT
> MATRIX_ROW_END_CHARPOS (row
))
12919 /* if PT is not in the glyph row, give up. */
12920 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
12922 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
12923 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
)
12924 && make_cursor_line_fully_visible_p
)
12926 if (PT
== MATRIX_ROW_END_CHARPOS (row
)
12927 && !row
->ends_at_zv_p
12928 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
12929 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
12930 else if (row
->height
> window_box_height (w
))
12932 /* If we end up in a partially visible line, let's
12933 make it fully visible, except when it's taller
12934 than the window, in which case we can't do much
12937 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
12941 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
12942 if (!cursor_row_fully_visible_p (w
, 0, 1))
12943 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
12945 rc
= CURSOR_MOVEMENT_SUCCESS
;
12949 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
12954 if (set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0))
12956 rc
= CURSOR_MOVEMENT_SUCCESS
;
12961 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
12962 && MATRIX_ROW_START_CHARPOS (row
) == PT
12963 && cursor_row_p (w
, row
));
12972 set_vertical_scroll_bar (w
)
12975 int start
, end
, whole
;
12977 /* Calculate the start and end positions for the current window.
12978 At some point, it would be nice to choose between scrollbars
12979 which reflect the whole buffer size, with special markers
12980 indicating narrowing, and scrollbars which reflect only the
12983 Note that mini-buffers sometimes aren't displaying any text. */
12984 if (!MINI_WINDOW_P (w
)
12985 || (w
== XWINDOW (minibuf_window
)
12986 && NILP (echo_area_buffer
[0])))
12988 struct buffer
*buf
= XBUFFER (w
->buffer
);
12989 whole
= BUF_ZV (buf
) - BUF_BEGV (buf
);
12990 start
= marker_position (w
->start
) - BUF_BEGV (buf
);
12991 /* I don't think this is guaranteed to be right. For the
12992 moment, we'll pretend it is. */
12993 end
= BUF_Z (buf
) - XFASTINT (w
->window_end_pos
) - BUF_BEGV (buf
);
12997 if (whole
< (end
- start
))
12998 whole
= end
- start
;
13001 start
= end
= whole
= 0;
13003 /* Indicate what this scroll bar ought to be displaying now. */
13004 if (FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
13005 (*FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
13006 (w
, end
- start
, whole
, start
);
13010 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
13011 selected_window is redisplayed.
13013 We can return without actually redisplaying the window if
13014 fonts_changed_p is nonzero. In that case, redisplay_internal will
13018 redisplay_window (window
, just_this_one_p
)
13019 Lisp_Object window
;
13020 int just_this_one_p
;
13022 struct window
*w
= XWINDOW (window
);
13023 struct frame
*f
= XFRAME (w
->frame
);
13024 struct buffer
*buffer
= XBUFFER (w
->buffer
);
13025 struct buffer
*old
= current_buffer
;
13026 struct text_pos lpoint
, opoint
, startp
;
13027 int update_mode_line
;
13030 /* Record it now because it's overwritten. */
13031 int current_matrix_up_to_date_p
= 0;
13032 int used_current_matrix_p
= 0;
13033 /* This is less strict than current_matrix_up_to_date_p.
13034 It indictes that the buffer contents and narrowing are unchanged. */
13035 int buffer_unchanged_p
= 0;
13036 int temp_scroll_step
= 0;
13037 int count
= SPECPDL_INDEX ();
13039 int centering_position
= -1;
13040 int last_line_misfit
= 0;
13041 int beg_unchanged
, end_unchanged
;
13043 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
13046 /* W must be a leaf window here. */
13047 xassert (!NILP (w
->buffer
));
13049 *w
->desired_matrix
->method
= 0;
13052 specbind (Qinhibit_point_motion_hooks
, Qt
);
13054 reconsider_clip_changes (w
, buffer
);
13056 /* Has the mode line to be updated? */
13057 update_mode_line
= (!NILP (w
->update_mode_line
)
13058 || update_mode_lines
13059 || buffer
->clip_changed
13060 || buffer
->prevent_redisplay_optimizations_p
);
13062 if (MINI_WINDOW_P (w
))
13064 if (w
== XWINDOW (echo_area_window
)
13065 && !NILP (echo_area_buffer
[0]))
13067 if (update_mode_line
)
13068 /* We may have to update a tty frame's menu bar or a
13069 tool-bar. Example `M-x C-h C-h C-g'. */
13070 goto finish_menu_bars
;
13072 /* We've already displayed the echo area glyphs in this window. */
13073 goto finish_scroll_bars
;
13075 else if ((w
!= XWINDOW (minibuf_window
)
13076 || minibuf_level
== 0)
13077 /* When buffer is nonempty, redisplay window normally. */
13078 && BUF_Z (XBUFFER (w
->buffer
)) == BUF_BEG (XBUFFER (w
->buffer
))
13079 /* Quail displays non-mini buffers in minibuffer window.
13080 In that case, redisplay the window normally. */
13081 && !NILP (Fmemq (w
->buffer
, Vminibuffer_list
)))
13083 /* W is a mini-buffer window, but it's not active, so clear
13085 int yb
= window_text_bottom_y (w
);
13086 struct glyph_row
*row
;
13089 for (y
= 0, row
= w
->desired_matrix
->rows
;
13091 y
+= row
->height
, ++row
)
13092 blank_row (w
, row
, y
);
13093 goto finish_scroll_bars
;
13096 clear_glyph_matrix (w
->desired_matrix
);
13099 /* Otherwise set up data on this window; select its buffer and point
13101 /* Really select the buffer, for the sake of buffer-local
13103 set_buffer_internal_1 (XBUFFER (w
->buffer
));
13104 SET_TEXT_POS (opoint
, PT
, PT_BYTE
);
13106 beg_unchanged
= BEG_UNCHANGED
;
13107 end_unchanged
= END_UNCHANGED
;
13109 current_matrix_up_to_date_p
13110 = (!NILP (w
->window_end_valid
)
13111 && !current_buffer
->clip_changed
13112 && !current_buffer
->prevent_redisplay_optimizations_p
13113 && XFASTINT (w
->last_modified
) >= MODIFF
13114 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
13117 = (!NILP (w
->window_end_valid
)
13118 && !current_buffer
->clip_changed
13119 && XFASTINT (w
->last_modified
) >= MODIFF
13120 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
13122 /* When windows_or_buffers_changed is non-zero, we can't rely on
13123 the window end being valid, so set it to nil there. */
13124 if (windows_or_buffers_changed
)
13126 /* If window starts on a continuation line, maybe adjust the
13127 window start in case the window's width changed. */
13128 if (XMARKER (w
->start
)->buffer
== current_buffer
)
13129 compute_window_start_on_continuation_line (w
);
13131 w
->window_end_valid
= Qnil
;
13134 /* Some sanity checks. */
13135 CHECK_WINDOW_END (w
);
13136 if (Z
== Z_BYTE
&& CHARPOS (opoint
) != BYTEPOS (opoint
))
13138 if (BYTEPOS (opoint
) < CHARPOS (opoint
))
13141 /* If %c is in mode line, update it if needed. */
13142 if (!NILP (w
->column_number_displayed
)
13143 /* This alternative quickly identifies a common case
13144 where no change is needed. */
13145 && !(PT
== XFASTINT (w
->last_point
)
13146 && XFASTINT (w
->last_modified
) >= MODIFF
13147 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
13148 && (XFASTINT (w
->column_number_displayed
)
13149 != (int) current_column ())) /* iftc */
13150 update_mode_line
= 1;
13152 /* Count number of windows showing the selected buffer. An indirect
13153 buffer counts as its base buffer. */
13154 if (!just_this_one_p
)
13156 struct buffer
*current_base
, *window_base
;
13157 current_base
= current_buffer
;
13158 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
13159 if (current_base
->base_buffer
)
13160 current_base
= current_base
->base_buffer
;
13161 if (window_base
->base_buffer
)
13162 window_base
= window_base
->base_buffer
;
13163 if (current_base
== window_base
)
13167 /* Point refers normally to the selected window. For any other
13168 window, set up appropriate value. */
13169 if (!EQ (window
, selected_window
))
13171 int new_pt
= XMARKER (w
->pointm
)->charpos
;
13172 int new_pt_byte
= marker_byte_position (w
->pointm
);
13176 new_pt_byte
= BEGV_BYTE
;
13177 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
13179 else if (new_pt
> (ZV
- 1))
13182 new_pt_byte
= ZV_BYTE
;
13183 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
13186 /* We don't use SET_PT so that the point-motion hooks don't run. */
13187 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
13190 /* If any of the character widths specified in the display table
13191 have changed, invalidate the width run cache. It's true that
13192 this may be a bit late to catch such changes, but the rest of
13193 redisplay goes (non-fatally) haywire when the display table is
13194 changed, so why should we worry about doing any better? */
13195 if (current_buffer
->width_run_cache
)
13197 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
13199 if (! disptab_matches_widthtab (disptab
,
13200 XVECTOR (current_buffer
->width_table
)))
13202 invalidate_region_cache (current_buffer
,
13203 current_buffer
->width_run_cache
,
13205 recompute_width_table (current_buffer
, disptab
);
13209 /* If window-start is screwed up, choose a new one. */
13210 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
13213 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
13215 /* If someone specified a new starting point but did not insist,
13216 check whether it can be used. */
13217 if (!NILP (w
->optional_new_start
)
13218 && CHARPOS (startp
) >= BEGV
13219 && CHARPOS (startp
) <= ZV
)
13221 w
->optional_new_start
= Qnil
;
13222 start_display (&it
, w
, startp
);
13223 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
13224 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
13225 if (IT_CHARPOS (it
) == PT
)
13226 w
->force_start
= Qt
;
13227 /* IT may overshoot PT if text at PT is invisible. */
13228 else if (IT_CHARPOS (it
) > PT
&& CHARPOS (startp
) <= PT
)
13229 w
->force_start
= Qt
;
13234 /* Handle case where place to start displaying has been specified,
13235 unless the specified location is outside the accessible range. */
13236 if (!NILP (w
->force_start
)
13237 || w
->frozen_window_start_p
)
13239 /* We set this later on if we have to adjust point. */
13243 w
->force_start
= Qnil
;
13245 w
->window_end_valid
= Qnil
;
13247 /* Forget any recorded base line for line number display. */
13248 if (!buffer_unchanged_p
)
13249 w
->base_line_number
= Qnil
;
13251 /* Redisplay the mode line. Select the buffer properly for that.
13252 Also, run the hook window-scroll-functions
13253 because we have scrolled. */
13254 /* Note, we do this after clearing force_start because
13255 if there's an error, it is better to forget about force_start
13256 than to get into an infinite loop calling the hook functions
13257 and having them get more errors. */
13258 if (!update_mode_line
13259 || ! NILP (Vwindow_scroll_functions
))
13261 update_mode_line
= 1;
13262 w
->update_mode_line
= Qt
;
13263 startp
= run_window_scroll_functions (window
, startp
);
13266 w
->last_modified
= make_number (0);
13267 w
->last_overlay_modified
= make_number (0);
13268 if (CHARPOS (startp
) < BEGV
)
13269 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
13270 else if (CHARPOS (startp
) > ZV
)
13271 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
13273 /* Redisplay, then check if cursor has been set during the
13274 redisplay. Give up if new fonts were loaded. */
13275 val
= try_window (window
, startp
, 1);
13278 w
->force_start
= Qt
;
13279 clear_glyph_matrix (w
->desired_matrix
);
13280 goto need_larger_matrices
;
13282 /* Point was outside the scroll margins. */
13284 new_vpos
= window_box_height (w
) / 2;
13286 if (w
->cursor
.vpos
< 0 && !w
->frozen_window_start_p
)
13288 /* If point does not appear, try to move point so it does
13289 appear. The desired matrix has been built above, so we
13290 can use it here. */
13291 new_vpos
= window_box_height (w
) / 2;
13294 if (!cursor_row_fully_visible_p (w
, 0, 0))
13296 /* Point does appear, but on a line partly visible at end of window.
13297 Move it back to a fully-visible line. */
13298 new_vpos
= window_box_height (w
);
13301 /* If we need to move point for either of the above reasons,
13302 now actually do it. */
13305 struct glyph_row
*row
;
13307 row
= MATRIX_FIRST_TEXT_ROW (w
->desired_matrix
);
13308 while (MATRIX_ROW_BOTTOM_Y (row
) < new_vpos
)
13311 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row
),
13312 MATRIX_ROW_START_BYTEPOS (row
));
13314 if (w
!= XWINDOW (selected_window
))
13315 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
13316 else if (current_buffer
== old
)
13317 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
13319 set_cursor_from_row (w
, row
, w
->desired_matrix
, 0, 0, 0, 0);
13321 /* If we are highlighting the region, then we just changed
13322 the region, so redisplay to show it. */
13323 if (!NILP (Vtransient_mark_mode
)
13324 && !NILP (current_buffer
->mark_active
))
13326 clear_glyph_matrix (w
->desired_matrix
);
13327 if (!try_window (window
, startp
, 0))
13328 goto need_larger_matrices
;
13333 debug_method_add (w
, "forced window start");
13338 /* Handle case where text has not changed, only point, and it has
13339 not moved off the frame, and we are not retrying after hscroll.
13340 (current_matrix_up_to_date_p is nonzero when retrying.) */
13341 if (current_matrix_up_to_date_p
13342 && (rc
= try_cursor_movement (window
, startp
, &temp_scroll_step
),
13343 rc
!= CURSOR_MOVEMENT_CANNOT_BE_USED
))
13347 case CURSOR_MOVEMENT_SUCCESS
:
13348 used_current_matrix_p
= 1;
13351 #if 0 /* try_cursor_movement never returns this value. */
13352 case CURSOR_MOVEMENT_NEED_LARGER_MATRICES
:
13353 goto need_larger_matrices
;
13356 case CURSOR_MOVEMENT_MUST_SCROLL
:
13357 goto try_to_scroll
;
13363 /* If current starting point was originally the beginning of a line
13364 but no longer is, find a new starting point. */
13365 else if (!NILP (w
->start_at_line_beg
)
13366 && !(CHARPOS (startp
) <= BEGV
13367 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n'))
13370 debug_method_add (w
, "recenter 1");
13375 /* Try scrolling with try_window_id. Value is > 0 if update has
13376 been done, it is -1 if we know that the same window start will
13377 not work. It is 0 if unsuccessful for some other reason. */
13378 else if ((tem
= try_window_id (w
)) != 0)
13381 debug_method_add (w
, "try_window_id %d", tem
);
13384 if (fonts_changed_p
)
13385 goto need_larger_matrices
;
13389 /* Otherwise try_window_id has returned -1 which means that we
13390 don't want the alternative below this comment to execute. */
13392 else if (CHARPOS (startp
) >= BEGV
13393 && CHARPOS (startp
) <= ZV
13394 && PT
>= CHARPOS (startp
)
13395 && (CHARPOS (startp
) < ZV
13396 /* Avoid starting at end of buffer. */
13397 || CHARPOS (startp
) == BEGV
13398 || (XFASTINT (w
->last_modified
) >= MODIFF
13399 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
13402 /* If first window line is a continuation line, and window start
13403 is inside the modified region, but the first change is before
13404 current window start, we must select a new window start.
13406 However, if this is the result of a down-mouse event (e.g. by
13407 extending the mouse-drag-overlay), we don't want to select a
13408 new window start, since that would change the position under
13409 the mouse, resulting in an unwanted mouse-movement rather
13410 than a simple mouse-click. */
13411 if (NILP (w
->start_at_line_beg
)
13412 && NILP (do_mouse_tracking
)
13413 && CHARPOS (startp
) > BEGV
13414 && CHARPOS (startp
) > BEG
+ beg_unchanged
13415 && CHARPOS (startp
) <= Z
- end_unchanged
)
13417 w
->force_start
= Qt
;
13418 if (XMARKER (w
->start
)->buffer
== current_buffer
)
13419 compute_window_start_on_continuation_line (w
);
13420 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
13425 debug_method_add (w
, "same window start");
13428 /* Try to redisplay starting at same place as before.
13429 If point has not moved off frame, accept the results. */
13430 if (!current_matrix_up_to_date_p
13431 /* Don't use try_window_reusing_current_matrix in this case
13432 because a window scroll function can have changed the
13434 || !NILP (Vwindow_scroll_functions
)
13435 || MINI_WINDOW_P (w
)
13436 || !(used_current_matrix_p
13437 = try_window_reusing_current_matrix (w
)))
13439 IF_DEBUG (debug_method_add (w
, "1"));
13440 if (try_window (window
, startp
, 1) < 0)
13441 /* -1 means we need to scroll.
13442 0 means we need new matrices, but fonts_changed_p
13443 is set in that case, so we will detect it below. */
13444 goto try_to_scroll
;
13447 if (fonts_changed_p
)
13448 goto need_larger_matrices
;
13450 if (w
->cursor
.vpos
>= 0)
13452 if (!just_this_one_p
13453 || current_buffer
->clip_changed
13454 || BEG_UNCHANGED
< CHARPOS (startp
))
13455 /* Forget any recorded base line for line number display. */
13456 w
->base_line_number
= Qnil
;
13458 if (!cursor_row_fully_visible_p (w
, 1, 0))
13460 clear_glyph_matrix (w
->desired_matrix
);
13461 last_line_misfit
= 1;
13463 /* Drop through and scroll. */
13468 clear_glyph_matrix (w
->desired_matrix
);
13473 w
->last_modified
= make_number (0);
13474 w
->last_overlay_modified
= make_number (0);
13476 /* Redisplay the mode line. Select the buffer properly for that. */
13477 if (!update_mode_line
)
13479 update_mode_line
= 1;
13480 w
->update_mode_line
= Qt
;
13483 /* Try to scroll by specified few lines. */
13484 if ((scroll_conservatively
13486 || temp_scroll_step
13487 || NUMBERP (current_buffer
->scroll_up_aggressively
)
13488 || NUMBERP (current_buffer
->scroll_down_aggressively
))
13489 && !current_buffer
->clip_changed
13490 && CHARPOS (startp
) >= BEGV
13491 && CHARPOS (startp
) <= ZV
)
13493 /* The function returns -1 if new fonts were loaded, 1 if
13494 successful, 0 if not successful. */
13495 int rc
= try_scrolling (window
, just_this_one_p
,
13496 scroll_conservatively
,
13498 temp_scroll_step
, last_line_misfit
);
13501 case SCROLLING_SUCCESS
:
13504 case SCROLLING_NEED_LARGER_MATRICES
:
13505 goto need_larger_matrices
;
13507 case SCROLLING_FAILED
:
13515 /* Finally, just choose place to start which centers point */
13518 if (centering_position
< 0)
13519 centering_position
= window_box_height (w
) / 2;
13522 debug_method_add (w
, "recenter");
13525 /* w->vscroll = 0; */
13527 /* Forget any previously recorded base line for line number display. */
13528 if (!buffer_unchanged_p
)
13529 w
->base_line_number
= Qnil
;
13531 /* Move backward half the height of the window. */
13532 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
13533 it
.current_y
= it
.last_visible_y
;
13534 move_it_vertically_backward (&it
, centering_position
);
13535 xassert (IT_CHARPOS (it
) >= BEGV
);
13537 /* The function move_it_vertically_backward may move over more
13538 than the specified y-distance. If it->w is small, e.g. a
13539 mini-buffer window, we may end up in front of the window's
13540 display area. Start displaying at the start of the line
13541 containing PT in this case. */
13542 if (it
.current_y
<= 0)
13544 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
13545 move_it_vertically_backward (&it
, 0);
13547 /* I think this assert is bogus if buffer contains
13548 invisible text or images. KFS. */
13549 xassert (IT_CHARPOS (it
) <= PT
);
13554 it
.current_x
= it
.hpos
= 0;
13556 /* Set startp here explicitly in case that helps avoid an infinite loop
13557 in case the window-scroll-functions functions get errors. */
13558 set_marker_both (w
->start
, Qnil
, IT_CHARPOS (it
), IT_BYTEPOS (it
));
13560 /* Run scroll hooks. */
13561 startp
= run_window_scroll_functions (window
, it
.current
.pos
);
13563 /* Redisplay the window. */
13564 if (!current_matrix_up_to_date_p
13565 || windows_or_buffers_changed
13566 || cursor_type_changed
13567 /* Don't use try_window_reusing_current_matrix in this case
13568 because it can have changed the buffer. */
13569 || !NILP (Vwindow_scroll_functions
)
13570 || !just_this_one_p
13571 || MINI_WINDOW_P (w
)
13572 || !(used_current_matrix_p
13573 = try_window_reusing_current_matrix (w
)))
13574 try_window (window
, startp
, 0);
13576 /* If new fonts have been loaded (due to fontsets), give up. We
13577 have to start a new redisplay since we need to re-adjust glyph
13579 if (fonts_changed_p
)
13580 goto need_larger_matrices
;
13582 /* If cursor did not appear assume that the middle of the window is
13583 in the first line of the window. Do it again with the next line.
13584 (Imagine a window of height 100, displaying two lines of height
13585 60. Moving back 50 from it->last_visible_y will end in the first
13587 if (w
->cursor
.vpos
< 0)
13589 if (!NILP (w
->window_end_valid
)
13590 && PT
>= Z
- XFASTINT (w
->window_end_pos
))
13592 clear_glyph_matrix (w
->desired_matrix
);
13593 move_it_by_lines (&it
, 1, 0);
13594 try_window (window
, it
.current
.pos
, 0);
13596 else if (PT
< IT_CHARPOS (it
))
13598 clear_glyph_matrix (w
->desired_matrix
);
13599 move_it_by_lines (&it
, -1, 0);
13600 try_window (window
, it
.current
.pos
, 0);
13604 /* Not much we can do about it. */
13608 /* Consider the following case: Window starts at BEGV, there is
13609 invisible, intangible text at BEGV, so that display starts at
13610 some point START > BEGV. It can happen that we are called with
13611 PT somewhere between BEGV and START. Try to handle that case. */
13612 if (w
->cursor
.vpos
< 0)
13614 struct glyph_row
*row
= w
->current_matrix
->rows
;
13615 if (row
->mode_line_p
)
13617 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
13620 if (!cursor_row_fully_visible_p (w
, 0, 0))
13622 /* If vscroll is enabled, disable it and try again. */
13626 clear_glyph_matrix (w
->desired_matrix
);
13630 /* If centering point failed to make the whole line visible,
13631 put point at the top instead. That has to make the whole line
13632 visible, if it can be done. */
13633 if (centering_position
== 0)
13636 clear_glyph_matrix (w
->desired_matrix
);
13637 centering_position
= 0;
13643 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
13644 w
->start_at_line_beg
= ((CHARPOS (startp
) == BEGV
13645 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n')
13648 /* Display the mode line, if we must. */
13649 if ((update_mode_line
13650 /* If window not full width, must redo its mode line
13651 if (a) the window to its side is being redone and
13652 (b) we do a frame-based redisplay. This is a consequence
13653 of how inverted lines are drawn in frame-based redisplay. */
13654 || (!just_this_one_p
13655 && !FRAME_WINDOW_P (f
)
13656 && !WINDOW_FULL_WIDTH_P (w
))
13657 /* Line number to display. */
13658 || INTEGERP (w
->base_line_pos
)
13659 /* Column number is displayed and different from the one displayed. */
13660 || (!NILP (w
->column_number_displayed
)
13661 && (XFASTINT (w
->column_number_displayed
)
13662 != (int) current_column ()))) /* iftc */
13663 /* This means that the window has a mode line. */
13664 && (WINDOW_WANTS_MODELINE_P (w
)
13665 || WINDOW_WANTS_HEADER_LINE_P (w
)))
13667 display_mode_lines (w
);
13669 /* If mode line height has changed, arrange for a thorough
13670 immediate redisplay using the correct mode line height. */
13671 if (WINDOW_WANTS_MODELINE_P (w
)
13672 && CURRENT_MODE_LINE_HEIGHT (w
) != DESIRED_MODE_LINE_HEIGHT (w
))
13674 fonts_changed_p
= 1;
13675 MATRIX_MODE_LINE_ROW (w
->current_matrix
)->height
13676 = DESIRED_MODE_LINE_HEIGHT (w
);
13679 /* If top line height has changed, arrange for a thorough
13680 immediate redisplay using the correct mode line height. */
13681 if (WINDOW_WANTS_HEADER_LINE_P (w
)
13682 && CURRENT_HEADER_LINE_HEIGHT (w
) != DESIRED_HEADER_LINE_HEIGHT (w
))
13684 fonts_changed_p
= 1;
13685 MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->height
13686 = DESIRED_HEADER_LINE_HEIGHT (w
);
13689 if (fonts_changed_p
)
13690 goto need_larger_matrices
;
13693 if (!line_number_displayed
13694 && !BUFFERP (w
->base_line_pos
))
13696 w
->base_line_pos
= Qnil
;
13697 w
->base_line_number
= Qnil
;
13702 /* When we reach a frame's selected window, redo the frame's menu bar. */
13703 if (update_mode_line
13704 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
13706 int redisplay_menu_p
= 0;
13707 int redisplay_tool_bar_p
= 0;
13709 if (FRAME_WINDOW_P (f
))
13711 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
13712 || defined (USE_GTK)
13713 redisplay_menu_p
= FRAME_EXTERNAL_MENU_BAR (f
);
13715 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
13719 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
13721 if (redisplay_menu_p
)
13722 display_menu_bar (w
);
13724 #ifdef HAVE_WINDOW_SYSTEM
13725 if (FRAME_WINDOW_P (f
))
13727 #if defined (USE_GTK) || USE_MAC_TOOLBAR
13728 redisplay_tool_bar_p
= FRAME_EXTERNAL_TOOL_BAR (f
);
13730 redisplay_tool_bar_p
= WINDOWP (f
->tool_bar_window
)
13731 && (FRAME_TOOL_BAR_LINES (f
) > 0
13732 || !NILP (Vauto_resize_tool_bars
));
13735 if (redisplay_tool_bar_p
&& redisplay_tool_bar (f
))
13737 extern int ignore_mouse_drag_p
;
13738 ignore_mouse_drag_p
= 1;
13744 #ifdef HAVE_WINDOW_SYSTEM
13745 if (FRAME_WINDOW_P (f
)
13746 && update_window_fringes (w
, (just_this_one_p
13747 || (!used_current_matrix_p
&& !overlay_arrow_seen
)
13748 || w
->pseudo_window_p
)))
13752 if (draw_window_fringes (w
, 1))
13753 x_draw_vertical_border (w
);
13757 #endif /* HAVE_WINDOW_SYSTEM */
13759 /* We go to this label, with fonts_changed_p nonzero,
13760 if it is necessary to try again using larger glyph matrices.
13761 We have to redeem the scroll bar even in this case,
13762 because the loop in redisplay_internal expects that. */
13763 need_larger_matrices
:
13765 finish_scroll_bars
:
13767 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
13769 /* Set the thumb's position and size. */
13770 set_vertical_scroll_bar (w
);
13772 /* Note that we actually used the scroll bar attached to this
13773 window, so it shouldn't be deleted at the end of redisplay. */
13774 if (FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
)
13775 (*FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
) (w
);
13778 /* Restore current_buffer and value of point in it. */
13779 TEMP_SET_PT_BOTH (CHARPOS (opoint
), BYTEPOS (opoint
));
13780 set_buffer_internal_1 (old
);
13781 /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
13782 shorter. This can be caused by log truncation in *Messages*. */
13783 if (CHARPOS (lpoint
) <= ZV
)
13784 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
13786 unbind_to (count
, Qnil
);
13790 /* Build the complete desired matrix of WINDOW with a window start
13791 buffer position POS.
13793 Value is 1 if successful. It is zero if fonts were loaded during
13794 redisplay which makes re-adjusting glyph matrices necessary, and -1
13795 if point would appear in the scroll margins.
13796 (We check that only if CHECK_MARGINS is nonzero. */
13799 try_window (window
, pos
, check_margins
)
13800 Lisp_Object window
;
13801 struct text_pos pos
;
13804 struct window
*w
= XWINDOW (window
);
13806 struct glyph_row
*last_text_row
= NULL
;
13807 struct frame
*f
= XFRAME (w
->frame
);
13809 /* Make POS the new window start. */
13810 set_marker_both (w
->start
, Qnil
, CHARPOS (pos
), BYTEPOS (pos
));
13812 /* Mark cursor position as unknown. No overlay arrow seen. */
13813 w
->cursor
.vpos
= -1;
13814 overlay_arrow_seen
= 0;
13816 /* Initialize iterator and info to start at POS. */
13817 start_display (&it
, w
, pos
);
13819 /* Display all lines of W. */
13820 while (it
.current_y
< it
.last_visible_y
)
13822 if (display_line (&it
))
13823 last_text_row
= it
.glyph_row
- 1;
13824 if (fonts_changed_p
)
13828 /* Don't let the cursor end in the scroll margins. */
13830 && !MINI_WINDOW_P (w
))
13832 int this_scroll_margin
;
13834 this_scroll_margin
= max (0, scroll_margin
);
13835 this_scroll_margin
= min (this_scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
13836 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
13838 if ((w
->cursor
.y
>= 0 /* not vscrolled */
13839 && w
->cursor
.y
< this_scroll_margin
13840 && CHARPOS (pos
) > BEGV
13841 && IT_CHARPOS (it
) < ZV
)
13842 /* rms: considering make_cursor_line_fully_visible_p here
13843 seems to give wrong results. We don't want to recenter
13844 when the last line is partly visible, we want to allow
13845 that case to be handled in the usual way. */
13846 || (w
->cursor
.y
+ 1) > it
.last_visible_y
)
13848 w
->cursor
.vpos
= -1;
13849 clear_glyph_matrix (w
->desired_matrix
);
13854 /* If bottom moved off end of frame, change mode line percentage. */
13855 if (XFASTINT (w
->window_end_pos
) <= 0
13856 && Z
!= IT_CHARPOS (it
))
13857 w
->update_mode_line
= Qt
;
13859 /* Set window_end_pos to the offset of the last character displayed
13860 on the window from the end of current_buffer. Set
13861 window_end_vpos to its row number. */
13864 xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row
));
13865 w
->window_end_bytepos
13866 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
13868 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
13870 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
13871 xassert (MATRIX_ROW (w
->desired_matrix
, XFASTINT (w
->window_end_vpos
))
13872 ->displays_text_p
);
13876 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
13877 w
->window_end_pos
= make_number (Z
- ZV
);
13878 w
->window_end_vpos
= make_number (0);
13881 /* But that is not valid info until redisplay finishes. */
13882 w
->window_end_valid
= Qnil
;
13888 /************************************************************************
13889 Window redisplay reusing current matrix when buffer has not changed
13890 ************************************************************************/
13892 /* Try redisplay of window W showing an unchanged buffer with a
13893 different window start than the last time it was displayed by
13894 reusing its current matrix. Value is non-zero if successful.
13895 W->start is the new window start. */
13898 try_window_reusing_current_matrix (w
)
13901 struct frame
*f
= XFRAME (w
->frame
);
13902 struct glyph_row
*row
, *bottom_row
;
13905 struct text_pos start
, new_start
;
13906 int nrows_scrolled
, i
;
13907 struct glyph_row
*last_text_row
;
13908 struct glyph_row
*last_reused_text_row
;
13909 struct glyph_row
*start_row
;
13910 int start_vpos
, min_y
, max_y
;
13913 if (inhibit_try_window_reusing
)
13917 if (/* This function doesn't handle terminal frames. */
13918 !FRAME_WINDOW_P (f
)
13919 /* Don't try to reuse the display if windows have been split
13921 || windows_or_buffers_changed
13922 || cursor_type_changed
)
13925 /* Can't do this if region may have changed. */
13926 if ((!NILP (Vtransient_mark_mode
)
13927 && !NILP (current_buffer
->mark_active
))
13928 || !NILP (w
->region_showing
)
13929 || !NILP (Vshow_trailing_whitespace
))
13932 /* If top-line visibility has changed, give up. */
13933 if (WINDOW_WANTS_HEADER_LINE_P (w
)
13934 != MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->mode_line_p
)
13937 /* Give up if old or new display is scrolled vertically. We could
13938 make this function handle this, but right now it doesn't. */
13939 start_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
13940 if (w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
))
13943 /* The variable new_start now holds the new window start. The old
13944 start `start' can be determined from the current matrix. */
13945 SET_TEXT_POS_FROM_MARKER (new_start
, w
->start
);
13946 start
= start_row
->start
.pos
;
13947 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
13949 /* Clear the desired matrix for the display below. */
13950 clear_glyph_matrix (w
->desired_matrix
);
13952 if (CHARPOS (new_start
) <= CHARPOS (start
))
13956 /* Don't use this method if the display starts with an ellipsis
13957 displayed for invisible text. It's not easy to handle that case
13958 below, and it's certainly not worth the effort since this is
13959 not a frequent case. */
13960 if (in_ellipses_for_invisible_text_p (&start_row
->start
, w
))
13963 IF_DEBUG (debug_method_add (w
, "twu1"));
13965 /* Display up to a row that can be reused. The variable
13966 last_text_row is set to the last row displayed that displays
13967 text. Note that it.vpos == 0 if or if not there is a
13968 header-line; it's not the same as the MATRIX_ROW_VPOS! */
13969 start_display (&it
, w
, new_start
);
13970 first_row_y
= it
.current_y
;
13971 w
->cursor
.vpos
= -1;
13972 last_text_row
= last_reused_text_row
= NULL
;
13974 while (it
.current_y
< it
.last_visible_y
13975 && !fonts_changed_p
)
13977 /* If we have reached into the characters in the START row,
13978 that means the line boundaries have changed. So we
13979 can't start copying with the row START. Maybe it will
13980 work to start copying with the following row. */
13981 while (IT_CHARPOS (it
) > CHARPOS (start
))
13983 /* Advance to the next row as the "start". */
13985 start
= start_row
->start
.pos
;
13986 /* If there are no more rows to try, or just one, give up. */
13987 if (start_row
== MATRIX_MODE_LINE_ROW (w
->current_matrix
) - 1
13988 || w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
)
13989 || CHARPOS (start
) == ZV
)
13991 clear_glyph_matrix (w
->desired_matrix
);
13995 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
13997 /* If we have reached alignment,
13998 we can copy the rest of the rows. */
13999 if (IT_CHARPOS (it
) == CHARPOS (start
))
14002 if (display_line (&it
))
14003 last_text_row
= it
.glyph_row
- 1;
14006 /* A value of current_y < last_visible_y means that we stopped
14007 at the previous window start, which in turn means that we
14008 have at least one reusable row. */
14009 if (it
.current_y
< it
.last_visible_y
)
14011 /* IT.vpos always starts from 0; it counts text lines. */
14012 nrows_scrolled
= it
.vpos
- (start_row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
));
14014 /* Find PT if not already found in the lines displayed. */
14015 if (w
->cursor
.vpos
< 0)
14017 int dy
= it
.current_y
- start_row
->y
;
14019 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
14020 row
= row_containing_pos (w
, PT
, row
, NULL
, dy
);
14022 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0,
14023 dy
, nrows_scrolled
);
14026 clear_glyph_matrix (w
->desired_matrix
);
14031 /* Scroll the display. Do it before the current matrix is
14032 changed. The problem here is that update has not yet
14033 run, i.e. part of the current matrix is not up to date.
14034 scroll_run_hook will clear the cursor, and use the
14035 current matrix to get the height of the row the cursor is
14037 run
.current_y
= start_row
->y
;
14038 run
.desired_y
= it
.current_y
;
14039 run
.height
= it
.last_visible_y
- it
.current_y
;
14041 if (run
.height
> 0 && run
.current_y
!= run
.desired_y
)
14044 FRAME_RIF (f
)->update_window_begin_hook (w
);
14045 FRAME_RIF (f
)->clear_window_mouse_face (w
);
14046 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
14047 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
14051 /* Shift current matrix down by nrows_scrolled lines. */
14052 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
14053 rotate_matrix (w
->current_matrix
,
14055 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
14058 /* Disable lines that must be updated. */
14059 for (i
= 0; i
< nrows_scrolled
; ++i
)
14060 (start_row
+ i
)->enabled_p
= 0;
14062 /* Re-compute Y positions. */
14063 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
14064 max_y
= it
.last_visible_y
;
14065 for (row
= start_row
+ nrows_scrolled
;
14069 row
->y
= it
.current_y
;
14070 row
->visible_height
= row
->height
;
14072 if (row
->y
< min_y
)
14073 row
->visible_height
-= min_y
- row
->y
;
14074 if (row
->y
+ row
->height
> max_y
)
14075 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
14076 row
->redraw_fringe_bitmaps_p
= 1;
14078 it
.current_y
+= row
->height
;
14080 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
14081 last_reused_text_row
= row
;
14082 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
.last_visible_y
)
14086 /* Disable lines in the current matrix which are now
14087 below the window. */
14088 for (++row
; row
< bottom_row
; ++row
)
14089 row
->enabled_p
= row
->mode_line_p
= 0;
14092 /* Update window_end_pos etc.; last_reused_text_row is the last
14093 reused row from the current matrix containing text, if any.
14094 The value of last_text_row is the last displayed line
14095 containing text. */
14096 if (last_reused_text_row
)
14098 w
->window_end_bytepos
14099 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_reused_text_row
);
14101 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_reused_text_row
));
14103 = make_number (MATRIX_ROW_VPOS (last_reused_text_row
,
14104 w
->current_matrix
));
14106 else if (last_text_row
)
14108 w
->window_end_bytepos
14109 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
14111 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
14113 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
14117 /* This window must be completely empty. */
14118 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
14119 w
->window_end_pos
= make_number (Z
- ZV
);
14120 w
->window_end_vpos
= make_number (0);
14122 w
->window_end_valid
= Qnil
;
14124 /* Update hint: don't try scrolling again in update_window. */
14125 w
->desired_matrix
->no_scrolling_p
= 1;
14128 debug_method_add (w
, "try_window_reusing_current_matrix 1");
14132 else if (CHARPOS (new_start
) > CHARPOS (start
))
14134 struct glyph_row
*pt_row
, *row
;
14135 struct glyph_row
*first_reusable_row
;
14136 struct glyph_row
*first_row_to_display
;
14138 int yb
= window_text_bottom_y (w
);
14140 /* Find the row starting at new_start, if there is one. Don't
14141 reuse a partially visible line at the end. */
14142 first_reusable_row
= start_row
;
14143 while (first_reusable_row
->enabled_p
14144 && MATRIX_ROW_BOTTOM_Y (first_reusable_row
) < yb
14145 && (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
14146 < CHARPOS (new_start
)))
14147 ++first_reusable_row
;
14149 /* Give up if there is no row to reuse. */
14150 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row
) >= yb
14151 || !first_reusable_row
->enabled_p
14152 || (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
14153 != CHARPOS (new_start
)))
14156 /* We can reuse fully visible rows beginning with
14157 first_reusable_row to the end of the window. Set
14158 first_row_to_display to the first row that cannot be reused.
14159 Set pt_row to the row containing point, if there is any. */
14161 for (first_row_to_display
= first_reusable_row
;
14162 MATRIX_ROW_BOTTOM_Y (first_row_to_display
) < yb
;
14163 ++first_row_to_display
)
14165 if (PT
>= MATRIX_ROW_START_CHARPOS (first_row_to_display
)
14166 && PT
< MATRIX_ROW_END_CHARPOS (first_row_to_display
))
14167 pt_row
= first_row_to_display
;
14170 /* Start displaying at the start of first_row_to_display. */
14171 xassert (first_row_to_display
->y
< yb
);
14172 init_to_row_start (&it
, w
, first_row_to_display
);
14174 nrows_scrolled
= (MATRIX_ROW_VPOS (first_reusable_row
, w
->current_matrix
)
14176 it
.vpos
= (MATRIX_ROW_VPOS (first_row_to_display
, w
->current_matrix
)
14178 it
.current_y
= (first_row_to_display
->y
- first_reusable_row
->y
14179 + WINDOW_HEADER_LINE_HEIGHT (w
));
14181 /* Display lines beginning with first_row_to_display in the
14182 desired matrix. Set last_text_row to the last row displayed
14183 that displays text. */
14184 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, it
.vpos
);
14185 if (pt_row
== NULL
)
14186 w
->cursor
.vpos
= -1;
14187 last_text_row
= NULL
;
14188 while (it
.current_y
< it
.last_visible_y
&& !fonts_changed_p
)
14189 if (display_line (&it
))
14190 last_text_row
= it
.glyph_row
- 1;
14192 /* Give up If point isn't in a row displayed or reused. */
14193 if (w
->cursor
.vpos
< 0)
14195 clear_glyph_matrix (w
->desired_matrix
);
14199 /* If point is in a reused row, adjust y and vpos of the cursor
14203 w
->cursor
.vpos
-= nrows_scrolled
;
14204 w
->cursor
.y
-= first_reusable_row
->y
- start_row
->y
;
14207 /* Scroll the display. */
14208 run
.current_y
= first_reusable_row
->y
;
14209 run
.desired_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
14210 run
.height
= it
.last_visible_y
- run
.current_y
;
14211 dy
= run
.current_y
- run
.desired_y
;
14216 FRAME_RIF (f
)->update_window_begin_hook (w
);
14217 FRAME_RIF (f
)->clear_window_mouse_face (w
);
14218 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
14219 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
14223 /* Adjust Y positions of reused rows. */
14224 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
14225 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
14226 max_y
= it
.last_visible_y
;
14227 for (row
= first_reusable_row
; row
< first_row_to_display
; ++row
)
14230 row
->visible_height
= row
->height
;
14231 if (row
->y
< min_y
)
14232 row
->visible_height
-= min_y
- row
->y
;
14233 if (row
->y
+ row
->height
> max_y
)
14234 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
14235 row
->redraw_fringe_bitmaps_p
= 1;
14238 /* Scroll the current matrix. */
14239 xassert (nrows_scrolled
> 0);
14240 rotate_matrix (w
->current_matrix
,
14242 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
14245 /* Disable rows not reused. */
14246 for (row
-= nrows_scrolled
; row
< bottom_row
; ++row
)
14247 row
->enabled_p
= 0;
14249 /* Point may have moved to a different line, so we cannot assume that
14250 the previous cursor position is valid; locate the correct row. */
14253 for (row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
14254 row
< bottom_row
&& PT
>= MATRIX_ROW_END_CHARPOS (row
);
14258 w
->cursor
.y
= row
->y
;
14260 if (row
< bottom_row
)
14262 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
14263 while (glyph
->charpos
< PT
)
14266 w
->cursor
.x
+= glyph
->pixel_width
;
14272 /* Adjust window end. A null value of last_text_row means that
14273 the window end is in reused rows which in turn means that
14274 only its vpos can have changed. */
14277 w
->window_end_bytepos
14278 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
14280 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
14282 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
14287 = make_number (XFASTINT (w
->window_end_vpos
) - nrows_scrolled
);
14290 w
->window_end_valid
= Qnil
;
14291 w
->desired_matrix
->no_scrolling_p
= 1;
14294 debug_method_add (w
, "try_window_reusing_current_matrix 2");
14304 /************************************************************************
14305 Window redisplay reusing current matrix when buffer has changed
14306 ************************************************************************/
14308 static struct glyph_row
*find_last_unchanged_at_beg_row
P_ ((struct window
*));
14309 static struct glyph_row
*find_first_unchanged_at_end_row
P_ ((struct window
*,
14311 static struct glyph_row
*
14312 find_last_row_displaying_text
P_ ((struct glyph_matrix
*, struct it
*,
14313 struct glyph_row
*));
14316 /* Return the last row in MATRIX displaying text. If row START is
14317 non-null, start searching with that row. IT gives the dimensions
14318 of the display. Value is null if matrix is empty; otherwise it is
14319 a pointer to the row found. */
14321 static struct glyph_row
*
14322 find_last_row_displaying_text (matrix
, it
, start
)
14323 struct glyph_matrix
*matrix
;
14325 struct glyph_row
*start
;
14327 struct glyph_row
*row
, *row_found
;
14329 /* Set row_found to the last row in IT->w's current matrix
14330 displaying text. The loop looks funny but think of partially
14333 row
= start
? start
: MATRIX_FIRST_TEXT_ROW (matrix
);
14334 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
14336 xassert (row
->enabled_p
);
14338 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
->last_visible_y
)
14347 /* Return the last row in the current matrix of W that is not affected
14348 by changes at the start of current_buffer that occurred since W's
14349 current matrix was built. Value is null if no such row exists.
14351 BEG_UNCHANGED us the number of characters unchanged at the start of
14352 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
14353 first changed character in current_buffer. Characters at positions <
14354 BEG + BEG_UNCHANGED are at the same buffer positions as they were
14355 when the current matrix was built. */
14357 static struct glyph_row
*
14358 find_last_unchanged_at_beg_row (w
)
14361 int first_changed_pos
= BEG
+ BEG_UNCHANGED
;
14362 struct glyph_row
*row
;
14363 struct glyph_row
*row_found
= NULL
;
14364 int yb
= window_text_bottom_y (w
);
14366 /* Find the last row displaying unchanged text. */
14367 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
14368 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
14369 && MATRIX_ROW_START_CHARPOS (row
) < first_changed_pos
)
14371 if (/* If row ends before first_changed_pos, it is unchanged,
14372 except in some case. */
14373 MATRIX_ROW_END_CHARPOS (row
) <= first_changed_pos
14374 /* When row ends in ZV and we write at ZV it is not
14376 && !row
->ends_at_zv_p
14377 /* When first_changed_pos is the end of a continued line,
14378 row is not unchanged because it may be no longer
14380 && !(MATRIX_ROW_END_CHARPOS (row
) == first_changed_pos
14381 && (row
->continued_p
14382 || row
->exact_window_width_line_p
)))
14385 /* Stop if last visible row. */
14386 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
14396 /* Find the first glyph row in the current matrix of W that is not
14397 affected by changes at the end of current_buffer since the
14398 time W's current matrix was built.
14400 Return in *DELTA the number of chars by which buffer positions in
14401 unchanged text at the end of current_buffer must be adjusted.
14403 Return in *DELTA_BYTES the corresponding number of bytes.
14405 Value is null if no such row exists, i.e. all rows are affected by
14408 static struct glyph_row
*
14409 find_first_unchanged_at_end_row (w
, delta
, delta_bytes
)
14411 int *delta
, *delta_bytes
;
14413 struct glyph_row
*row
;
14414 struct glyph_row
*row_found
= NULL
;
14416 *delta
= *delta_bytes
= 0;
14418 /* Display must not have been paused, otherwise the current matrix
14419 is not up to date. */
14420 if (NILP (w
->window_end_valid
))
14423 /* A value of window_end_pos >= END_UNCHANGED means that the window
14424 end is in the range of changed text. If so, there is no
14425 unchanged row at the end of W's current matrix. */
14426 if (XFASTINT (w
->window_end_pos
) >= END_UNCHANGED
)
14429 /* Set row to the last row in W's current matrix displaying text. */
14430 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
14432 /* If matrix is entirely empty, no unchanged row exists. */
14433 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
14435 /* The value of row is the last glyph row in the matrix having a
14436 meaningful buffer position in it. The end position of row
14437 corresponds to window_end_pos. This allows us to translate
14438 buffer positions in the current matrix to current buffer
14439 positions for characters not in changed text. */
14440 int Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
14441 int Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
14442 int last_unchanged_pos
, last_unchanged_pos_old
;
14443 struct glyph_row
*first_text_row
14444 = MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
14446 *delta
= Z
- Z_old
;
14447 *delta_bytes
= Z_BYTE
- Z_BYTE_old
;
14449 /* Set last_unchanged_pos to the buffer position of the last
14450 character in the buffer that has not been changed. Z is the
14451 index + 1 of the last character in current_buffer, i.e. by
14452 subtracting END_UNCHANGED we get the index of the last
14453 unchanged character, and we have to add BEG to get its buffer
14455 last_unchanged_pos
= Z
- END_UNCHANGED
+ BEG
;
14456 last_unchanged_pos_old
= last_unchanged_pos
- *delta
;
14458 /* Search backward from ROW for a row displaying a line that
14459 starts at a minimum position >= last_unchanged_pos_old. */
14460 for (; row
> first_text_row
; --row
)
14462 /* This used to abort, but it can happen.
14463 It is ok to just stop the search instead here. KFS. */
14464 if (!row
->enabled_p
|| !MATRIX_ROW_DISPLAYS_TEXT_P (row
))
14467 if (MATRIX_ROW_START_CHARPOS (row
) >= last_unchanged_pos_old
)
14472 if (row_found
&& !MATRIX_ROW_DISPLAYS_TEXT_P (row_found
))
14479 /* Make sure that glyph rows in the current matrix of window W
14480 reference the same glyph memory as corresponding rows in the
14481 frame's frame matrix. This function is called after scrolling W's
14482 current matrix on a terminal frame in try_window_id and
14483 try_window_reusing_current_matrix. */
14486 sync_frame_with_window_matrix_rows (w
)
14489 struct frame
*f
= XFRAME (w
->frame
);
14490 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
14492 /* Preconditions: W must be a leaf window and full-width. Its frame
14493 must have a frame matrix. */
14494 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
14495 xassert (WINDOW_FULL_WIDTH_P (w
));
14496 xassert (!FRAME_WINDOW_P (f
));
14498 /* If W is a full-width window, glyph pointers in W's current matrix
14499 have, by definition, to be the same as glyph pointers in the
14500 corresponding frame matrix. Note that frame matrices have no
14501 marginal areas (see build_frame_matrix). */
14502 window_row
= w
->current_matrix
->rows
;
14503 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
14504 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
14505 while (window_row
< window_row_end
)
14507 struct glyph
*start
= window_row
->glyphs
[LEFT_MARGIN_AREA
];
14508 struct glyph
*end
= window_row
->glyphs
[LAST_AREA
];
14510 frame_row
->glyphs
[LEFT_MARGIN_AREA
] = start
;
14511 frame_row
->glyphs
[TEXT_AREA
] = start
;
14512 frame_row
->glyphs
[RIGHT_MARGIN_AREA
] = end
;
14513 frame_row
->glyphs
[LAST_AREA
] = end
;
14515 /* Disable frame rows whose corresponding window rows have
14516 been disabled in try_window_id. */
14517 if (!window_row
->enabled_p
)
14518 frame_row
->enabled_p
= 0;
14520 ++window_row
, ++frame_row
;
14525 /* Find the glyph row in window W containing CHARPOS. Consider all
14526 rows between START and END (not inclusive). END null means search
14527 all rows to the end of the display area of W. Value is the row
14528 containing CHARPOS or null. */
14531 row_containing_pos (w
, charpos
, start
, end
, dy
)
14534 struct glyph_row
*start
, *end
;
14537 struct glyph_row
*row
= start
;
14540 /* If we happen to start on a header-line, skip that. */
14541 if (row
->mode_line_p
)
14544 if ((end
&& row
>= end
) || !row
->enabled_p
)
14547 last_y
= window_text_bottom_y (w
) - dy
;
14551 /* Give up if we have gone too far. */
14552 if (end
&& row
>= end
)
14554 /* This formerly returned if they were equal.
14555 I think that both quantities are of a "last plus one" type;
14556 if so, when they are equal, the row is within the screen. -- rms. */
14557 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
)
14560 /* If it is in this row, return this row. */
14561 if (! (MATRIX_ROW_END_CHARPOS (row
) < charpos
14562 || (MATRIX_ROW_END_CHARPOS (row
) == charpos
14563 /* The end position of a row equals the start
14564 position of the next row. If CHARPOS is there, we
14565 would rather display it in the next line, except
14566 when this line ends in ZV. */
14567 && !row
->ends_at_zv_p
14568 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
14569 && charpos
>= MATRIX_ROW_START_CHARPOS (row
))
14576 /* Try to redisplay window W by reusing its existing display. W's
14577 current matrix must be up to date when this function is called,
14578 i.e. window_end_valid must not be nil.
14582 1 if display has been updated
14583 0 if otherwise unsuccessful
14584 -1 if redisplay with same window start is known not to succeed
14586 The following steps are performed:
14588 1. Find the last row in the current matrix of W that is not
14589 affected by changes at the start of current_buffer. If no such row
14592 2. Find the first row in W's current matrix that is not affected by
14593 changes at the end of current_buffer. Maybe there is no such row.
14595 3. Display lines beginning with the row + 1 found in step 1 to the
14596 row found in step 2 or, if step 2 didn't find a row, to the end of
14599 4. If cursor is not known to appear on the window, give up.
14601 5. If display stopped at the row found in step 2, scroll the
14602 display and current matrix as needed.
14604 6. Maybe display some lines at the end of W, if we must. This can
14605 happen under various circumstances, like a partially visible line
14606 becoming fully visible, or because newly displayed lines are displayed
14607 in smaller font sizes.
14609 7. Update W's window end information. */
14615 struct frame
*f
= XFRAME (w
->frame
);
14616 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
14617 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
14618 struct glyph_row
*last_unchanged_at_beg_row
;
14619 struct glyph_row
*first_unchanged_at_end_row
;
14620 struct glyph_row
*row
;
14621 struct glyph_row
*bottom_row
;
14624 int delta
= 0, delta_bytes
= 0, stop_pos
, dvpos
, dy
;
14625 struct text_pos start_pos
;
14627 int first_unchanged_at_end_vpos
= 0;
14628 struct glyph_row
*last_text_row
, *last_text_row_at_end
;
14629 struct text_pos start
;
14630 int first_changed_charpos
, last_changed_charpos
;
14633 if (inhibit_try_window_id
)
14637 /* This is handy for debugging. */
14639 #define GIVE_UP(X) \
14641 fprintf (stderr, "try_window_id give up %d\n", (X)); \
14645 #define GIVE_UP(X) return 0
14648 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
14650 /* Don't use this for mini-windows because these can show
14651 messages and mini-buffers, and we don't handle that here. */
14652 if (MINI_WINDOW_P (w
))
14655 /* This flag is used to prevent redisplay optimizations. */
14656 if (windows_or_buffers_changed
|| cursor_type_changed
)
14659 /* Verify that narrowing has not changed.
14660 Also verify that we were not told to prevent redisplay optimizations.
14661 It would be nice to further
14662 reduce the number of cases where this prevents try_window_id. */
14663 if (current_buffer
->clip_changed
14664 || current_buffer
->prevent_redisplay_optimizations_p
)
14667 /* Window must either use window-based redisplay or be full width. */
14668 if (!FRAME_WINDOW_P (f
)
14669 && (!FRAME_LINE_INS_DEL_OK (f
)
14670 || !WINDOW_FULL_WIDTH_P (w
)))
14673 /* Give up if point is not known NOT to appear in W. */
14674 if (PT
< CHARPOS (start
))
14677 /* Another way to prevent redisplay optimizations. */
14678 if (XFASTINT (w
->last_modified
) == 0)
14681 /* Verify that window is not hscrolled. */
14682 if (XFASTINT (w
->hscroll
) != 0)
14685 /* Verify that display wasn't paused. */
14686 if (NILP (w
->window_end_valid
))
14689 /* Can't use this if highlighting a region because a cursor movement
14690 will do more than just set the cursor. */
14691 if (!NILP (Vtransient_mark_mode
)
14692 && !NILP (current_buffer
->mark_active
))
14695 /* Likewise if highlighting trailing whitespace. */
14696 if (!NILP (Vshow_trailing_whitespace
))
14699 /* Likewise if showing a region. */
14700 if (!NILP (w
->region_showing
))
14703 /* Can use this if overlay arrow position and or string have changed. */
14704 if (overlay_arrows_changed_p ())
14708 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
14709 only if buffer has really changed. The reason is that the gap is
14710 initially at Z for freshly visited files. The code below would
14711 set end_unchanged to 0 in that case. */
14712 if (MODIFF
> SAVE_MODIFF
14713 /* This seems to happen sometimes after saving a buffer. */
14714 || BEG_UNCHANGED
+ END_UNCHANGED
> Z_BYTE
)
14716 if (GPT
- BEG
< BEG_UNCHANGED
)
14717 BEG_UNCHANGED
= GPT
- BEG
;
14718 if (Z
- GPT
< END_UNCHANGED
)
14719 END_UNCHANGED
= Z
- GPT
;
14722 /* The position of the first and last character that has been changed. */
14723 first_changed_charpos
= BEG
+ BEG_UNCHANGED
;
14724 last_changed_charpos
= Z
- END_UNCHANGED
;
14726 /* If window starts after a line end, and the last change is in
14727 front of that newline, then changes don't affect the display.
14728 This case happens with stealth-fontification. Note that although
14729 the display is unchanged, glyph positions in the matrix have to
14730 be adjusted, of course. */
14731 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
14732 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
14733 && ((last_changed_charpos
< CHARPOS (start
)
14734 && CHARPOS (start
) == BEGV
)
14735 || (last_changed_charpos
< CHARPOS (start
) - 1
14736 && FETCH_BYTE (BYTEPOS (start
) - 1) == '\n')))
14738 int Z_old
, delta
, Z_BYTE_old
, delta_bytes
;
14739 struct glyph_row
*r0
;
14741 /* Compute how many chars/bytes have been added to or removed
14742 from the buffer. */
14743 Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
14744 Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
14746 delta_bytes
= Z_BYTE
- Z_BYTE_old
;
14748 /* Give up if PT is not in the window. Note that it already has
14749 been checked at the start of try_window_id that PT is not in
14750 front of the window start. */
14751 if (PT
>= MATRIX_ROW_END_CHARPOS (row
) + delta
)
14754 /* If window start is unchanged, we can reuse the whole matrix
14755 as is, after adjusting glyph positions. No need to compute
14756 the window end again, since its offset from Z hasn't changed. */
14757 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
14758 if (CHARPOS (start
) == MATRIX_ROW_START_CHARPOS (r0
) + delta
14759 && BYTEPOS (start
) == MATRIX_ROW_START_BYTEPOS (r0
) + delta_bytes
14760 /* PT must not be in a partially visible line. */
14761 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
) + delta
14762 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
14764 /* Adjust positions in the glyph matrix. */
14765 if (delta
|| delta_bytes
)
14767 struct glyph_row
*r1
14768 = MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
14769 increment_matrix_positions (w
->current_matrix
,
14770 MATRIX_ROW_VPOS (r0
, current_matrix
),
14771 MATRIX_ROW_VPOS (r1
, current_matrix
),
14772 delta
, delta_bytes
);
14775 /* Set the cursor. */
14776 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
14778 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
14785 /* Handle the case that changes are all below what is displayed in
14786 the window, and that PT is in the window. This shortcut cannot
14787 be taken if ZV is visible in the window, and text has been added
14788 there that is visible in the window. */
14789 if (first_changed_charpos
>= MATRIX_ROW_END_CHARPOS (row
)
14790 /* ZV is not visible in the window, or there are no
14791 changes at ZV, actually. */
14792 && (current_matrix
->zv
> MATRIX_ROW_END_CHARPOS (row
)
14793 || first_changed_charpos
== last_changed_charpos
))
14795 struct glyph_row
*r0
;
14797 /* Give up if PT is not in the window. Note that it already has
14798 been checked at the start of try_window_id that PT is not in
14799 front of the window start. */
14800 if (PT
>= MATRIX_ROW_END_CHARPOS (row
))
14803 /* If window start is unchanged, we can reuse the whole matrix
14804 as is, without changing glyph positions since no text has
14805 been added/removed in front of the window end. */
14806 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
14807 if (TEXT_POS_EQUAL_P (start
, r0
->start
.pos
)
14808 /* PT must not be in a partially visible line. */
14809 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
)
14810 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
14812 /* We have to compute the window end anew since text
14813 can have been added/removed after it. */
14815 = make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
14816 w
->window_end_bytepos
14817 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
14819 /* Set the cursor. */
14820 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
14822 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
14829 /* Give up if window start is in the changed area.
14831 The condition used to read
14833 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
14835 but why that was tested escapes me at the moment. */
14836 if (CHARPOS (start
) >= first_changed_charpos
14837 && CHARPOS (start
) <= last_changed_charpos
)
14840 /* Check that window start agrees with the start of the first glyph
14841 row in its current matrix. Check this after we know the window
14842 start is not in changed text, otherwise positions would not be
14844 row
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
14845 if (!TEXT_POS_EQUAL_P (start
, row
->start
.pos
))
14848 /* Give up if the window ends in strings. Overlay strings
14849 at the end are difficult to handle, so don't try. */
14850 row
= MATRIX_ROW (current_matrix
, XFASTINT (w
->window_end_vpos
));
14851 if (MATRIX_ROW_START_CHARPOS (row
) == MATRIX_ROW_END_CHARPOS (row
))
14854 /* Compute the position at which we have to start displaying new
14855 lines. Some of the lines at the top of the window might be
14856 reusable because they are not displaying changed text. Find the
14857 last row in W's current matrix not affected by changes at the
14858 start of current_buffer. Value is null if changes start in the
14859 first line of window. */
14860 last_unchanged_at_beg_row
= find_last_unchanged_at_beg_row (w
);
14861 if (last_unchanged_at_beg_row
)
14863 /* Avoid starting to display in the moddle of a character, a TAB
14864 for instance. This is easier than to set up the iterator
14865 exactly, and it's not a frequent case, so the additional
14866 effort wouldn't really pay off. */
14867 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
)
14868 || last_unchanged_at_beg_row
->ends_in_newline_from_string_p
)
14869 && last_unchanged_at_beg_row
> w
->current_matrix
->rows
)
14870 --last_unchanged_at_beg_row
;
14872 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
))
14875 if (init_to_row_end (&it
, w
, last_unchanged_at_beg_row
) == 0)
14877 start_pos
= it
.current
.pos
;
14879 /* Start displaying new lines in the desired matrix at the same
14880 vpos we would use in the current matrix, i.e. below
14881 last_unchanged_at_beg_row. */
14882 it
.vpos
= 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row
,
14884 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
14885 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row
);
14887 xassert (it
.hpos
== 0 && it
.current_x
== 0);
14891 /* There are no reusable lines at the start of the window.
14892 Start displaying in the first text line. */
14893 start_display (&it
, w
, start
);
14894 it
.vpos
= it
.first_vpos
;
14895 start_pos
= it
.current
.pos
;
14898 /* Find the first row that is not affected by changes at the end of
14899 the buffer. Value will be null if there is no unchanged row, in
14900 which case we must redisplay to the end of the window. delta
14901 will be set to the value by which buffer positions beginning with
14902 first_unchanged_at_end_row have to be adjusted due to text
14904 first_unchanged_at_end_row
14905 = find_first_unchanged_at_end_row (w
, &delta
, &delta_bytes
);
14906 IF_DEBUG (debug_delta
= delta
);
14907 IF_DEBUG (debug_delta_bytes
= delta_bytes
);
14909 /* Set stop_pos to the buffer position up to which we will have to
14910 display new lines. If first_unchanged_at_end_row != NULL, this
14911 is the buffer position of the start of the line displayed in that
14912 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
14913 that we don't stop at a buffer position. */
14915 if (first_unchanged_at_end_row
)
14917 xassert (last_unchanged_at_beg_row
== NULL
14918 || first_unchanged_at_end_row
>= last_unchanged_at_beg_row
);
14920 /* If this is a continuation line, move forward to the next one
14921 that isn't. Changes in lines above affect this line.
14922 Caution: this may move first_unchanged_at_end_row to a row
14923 not displaying text. */
14924 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row
)
14925 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
14926 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
14927 < it
.last_visible_y
))
14928 ++first_unchanged_at_end_row
;
14930 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
14931 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
14932 >= it
.last_visible_y
))
14933 first_unchanged_at_end_row
= NULL
;
14936 stop_pos
= (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row
)
14938 first_unchanged_at_end_vpos
14939 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, current_matrix
);
14940 xassert (stop_pos
>= Z
- END_UNCHANGED
);
14943 else if (last_unchanged_at_beg_row
== NULL
)
14949 /* Either there is no unchanged row at the end, or the one we have
14950 now displays text. This is a necessary condition for the window
14951 end pos calculation at the end of this function. */
14952 xassert (first_unchanged_at_end_row
== NULL
14953 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
14955 debug_last_unchanged_at_beg_vpos
14956 = (last_unchanged_at_beg_row
14957 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row
, current_matrix
)
14959 debug_first_unchanged_at_end_vpos
= first_unchanged_at_end_vpos
;
14961 #endif /* GLYPH_DEBUG != 0 */
14964 /* Display new lines. Set last_text_row to the last new line
14965 displayed which has text on it, i.e. might end up as being the
14966 line where the window_end_vpos is. */
14967 w
->cursor
.vpos
= -1;
14968 last_text_row
= NULL
;
14969 overlay_arrow_seen
= 0;
14970 while (it
.current_y
< it
.last_visible_y
14971 && !fonts_changed_p
14972 && (first_unchanged_at_end_row
== NULL
14973 || IT_CHARPOS (it
) < stop_pos
))
14975 if (display_line (&it
))
14976 last_text_row
= it
.glyph_row
- 1;
14979 if (fonts_changed_p
)
14983 /* Compute differences in buffer positions, y-positions etc. for
14984 lines reused at the bottom of the window. Compute what we can
14986 if (first_unchanged_at_end_row
14987 /* No lines reused because we displayed everything up to the
14988 bottom of the window. */
14989 && it
.current_y
< it
.last_visible_y
)
14992 - MATRIX_ROW_VPOS (first_unchanged_at_end_row
,
14994 dy
= it
.current_y
- first_unchanged_at_end_row
->y
;
14995 run
.current_y
= first_unchanged_at_end_row
->y
;
14996 run
.desired_y
= run
.current_y
+ dy
;
14997 run
.height
= it
.last_visible_y
- max (run
.current_y
, run
.desired_y
);
15001 delta
= dvpos
= dy
= run
.current_y
= run
.desired_y
= run
.height
= 0;
15002 first_unchanged_at_end_row
= NULL
;
15004 IF_DEBUG (debug_dvpos
= dvpos
; debug_dy
= dy
);
15007 /* Find the cursor if not already found. We have to decide whether
15008 PT will appear on this window (it sometimes doesn't, but this is
15009 not a very frequent case.) This decision has to be made before
15010 the current matrix is altered. A value of cursor.vpos < 0 means
15011 that PT is either in one of the lines beginning at
15012 first_unchanged_at_end_row or below the window. Don't care for
15013 lines that might be displayed later at the window end; as
15014 mentioned, this is not a frequent case. */
15015 if (w
->cursor
.vpos
< 0)
15017 /* Cursor in unchanged rows at the top? */
15018 if (PT
< CHARPOS (start_pos
)
15019 && last_unchanged_at_beg_row
)
15021 row
= row_containing_pos (w
, PT
,
15022 MATRIX_FIRST_TEXT_ROW (w
->current_matrix
),
15023 last_unchanged_at_beg_row
+ 1, 0);
15025 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
15028 /* Start from first_unchanged_at_end_row looking for PT. */
15029 else if (first_unchanged_at_end_row
)
15031 row
= row_containing_pos (w
, PT
- delta
,
15032 first_unchanged_at_end_row
, NULL
, 0);
15034 set_cursor_from_row (w
, row
, w
->current_matrix
, delta
,
15035 delta_bytes
, dy
, dvpos
);
15038 /* Give up if cursor was not found. */
15039 if (w
->cursor
.vpos
< 0)
15041 clear_glyph_matrix (w
->desired_matrix
);
15046 /* Don't let the cursor end in the scroll margins. */
15048 int this_scroll_margin
, cursor_height
;
15050 this_scroll_margin
= max (0, scroll_margin
);
15051 this_scroll_margin
= min (this_scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
15052 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
15053 cursor_height
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
)->height
;
15055 if ((w
->cursor
.y
< this_scroll_margin
15056 && CHARPOS (start
) > BEGV
)
15057 /* Old redisplay didn't take scroll margin into account at the bottom,
15058 but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
15059 || (w
->cursor
.y
+ (make_cursor_line_fully_visible_p
15060 ? cursor_height
+ this_scroll_margin
15061 : 1)) > it
.last_visible_y
)
15063 w
->cursor
.vpos
= -1;
15064 clear_glyph_matrix (w
->desired_matrix
);
15069 /* Scroll the display. Do it before changing the current matrix so
15070 that xterm.c doesn't get confused about where the cursor glyph is
15072 if (dy
&& run
.height
)
15076 if (FRAME_WINDOW_P (f
))
15078 FRAME_RIF (f
)->update_window_begin_hook (w
);
15079 FRAME_RIF (f
)->clear_window_mouse_face (w
);
15080 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
15081 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
15085 /* Terminal frame. In this case, dvpos gives the number of
15086 lines to scroll by; dvpos < 0 means scroll up. */
15087 int first_unchanged_at_end_vpos
15088 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, w
->current_matrix
);
15089 int from
= WINDOW_TOP_EDGE_LINE (w
) + first_unchanged_at_end_vpos
;
15090 int end
= (WINDOW_TOP_EDGE_LINE (w
)
15091 + (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0)
15092 + window_internal_height (w
));
15094 /* Perform the operation on the screen. */
15097 /* Scroll last_unchanged_at_beg_row to the end of the
15098 window down dvpos lines. */
15099 set_terminal_window (f
, end
);
15101 /* On dumb terminals delete dvpos lines at the end
15102 before inserting dvpos empty lines. */
15103 if (!FRAME_SCROLL_REGION_OK (f
))
15104 ins_del_lines (f
, end
- dvpos
, -dvpos
);
15106 /* Insert dvpos empty lines in front of
15107 last_unchanged_at_beg_row. */
15108 ins_del_lines (f
, from
, dvpos
);
15110 else if (dvpos
< 0)
15112 /* Scroll up last_unchanged_at_beg_vpos to the end of
15113 the window to last_unchanged_at_beg_vpos - |dvpos|. */
15114 set_terminal_window (f
, end
);
15116 /* Delete dvpos lines in front of
15117 last_unchanged_at_beg_vpos. ins_del_lines will set
15118 the cursor to the given vpos and emit |dvpos| delete
15120 ins_del_lines (f
, from
+ dvpos
, dvpos
);
15122 /* On a dumb terminal insert dvpos empty lines at the
15124 if (!FRAME_SCROLL_REGION_OK (f
))
15125 ins_del_lines (f
, end
+ dvpos
, -dvpos
);
15128 set_terminal_window (f
, 0);
15134 /* Shift reused rows of the current matrix to the right position.
15135 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
15137 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
15138 bottom_vpos
= MATRIX_ROW_VPOS (bottom_row
, current_matrix
);
15141 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
+ dvpos
,
15142 bottom_vpos
, dvpos
);
15143 enable_glyph_matrix_rows (current_matrix
, bottom_vpos
+ dvpos
,
15146 else if (dvpos
> 0)
15148 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
,
15149 bottom_vpos
, dvpos
);
15150 enable_glyph_matrix_rows (current_matrix
, first_unchanged_at_end_vpos
,
15151 first_unchanged_at_end_vpos
+ dvpos
, 0);
15154 /* For frame-based redisplay, make sure that current frame and window
15155 matrix are in sync with respect to glyph memory. */
15156 if (!FRAME_WINDOW_P (f
))
15157 sync_frame_with_window_matrix_rows (w
);
15159 /* Adjust buffer positions in reused rows. */
15160 if (delta
|| delta_bytes
)
15161 increment_matrix_positions (current_matrix
,
15162 first_unchanged_at_end_vpos
+ dvpos
,
15163 bottom_vpos
, delta
, delta_bytes
);
15165 /* Adjust Y positions. */
15167 shift_glyph_matrix (w
, current_matrix
,
15168 first_unchanged_at_end_vpos
+ dvpos
,
15171 if (first_unchanged_at_end_row
)
15173 first_unchanged_at_end_row
+= dvpos
;
15174 if (first_unchanged_at_end_row
->y
>= it
.last_visible_y
15175 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
))
15176 first_unchanged_at_end_row
= NULL
;
15179 /* If scrolling up, there may be some lines to display at the end of
15181 last_text_row_at_end
= NULL
;
15184 /* Scrolling up can leave for example a partially visible line
15185 at the end of the window to be redisplayed. */
15186 /* Set last_row to the glyph row in the current matrix where the
15187 window end line is found. It has been moved up or down in
15188 the matrix by dvpos. */
15189 int last_vpos
= XFASTINT (w
->window_end_vpos
) + dvpos
;
15190 struct glyph_row
*last_row
= MATRIX_ROW (current_matrix
, last_vpos
);
15192 /* If last_row is the window end line, it should display text. */
15193 xassert (last_row
->displays_text_p
);
15195 /* If window end line was partially visible before, begin
15196 displaying at that line. Otherwise begin displaying with the
15197 line following it. */
15198 if (MATRIX_ROW_BOTTOM_Y (last_row
) - dy
>= it
.last_visible_y
)
15200 init_to_row_start (&it
, w
, last_row
);
15201 it
.vpos
= last_vpos
;
15202 it
.current_y
= last_row
->y
;
15206 init_to_row_end (&it
, w
, last_row
);
15207 it
.vpos
= 1 + last_vpos
;
15208 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_row
);
15212 /* We may start in a continuation line. If so, we have to
15213 get the right continuation_lines_width and current_x. */
15214 it
.continuation_lines_width
= last_row
->continuation_lines_width
;
15215 it
.hpos
= it
.current_x
= 0;
15217 /* Display the rest of the lines at the window end. */
15218 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
15219 while (it
.current_y
< it
.last_visible_y
15220 && !fonts_changed_p
)
15222 /* Is it always sure that the display agrees with lines in
15223 the current matrix? I don't think so, so we mark rows
15224 displayed invalid in the current matrix by setting their
15225 enabled_p flag to zero. */
15226 MATRIX_ROW (w
->current_matrix
, it
.vpos
)->enabled_p
= 0;
15227 if (display_line (&it
))
15228 last_text_row_at_end
= it
.glyph_row
- 1;
15232 /* Update window_end_pos and window_end_vpos. */
15233 if (first_unchanged_at_end_row
15234 && !last_text_row_at_end
)
15236 /* Window end line if one of the preserved rows from the current
15237 matrix. Set row to the last row displaying text in current
15238 matrix starting at first_unchanged_at_end_row, after
15240 xassert (first_unchanged_at_end_row
->displays_text_p
);
15241 row
= find_last_row_displaying_text (w
->current_matrix
, &it
,
15242 first_unchanged_at_end_row
);
15243 xassert (row
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
));
15245 w
->window_end_pos
= make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
15246 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
15248 = make_number (MATRIX_ROW_VPOS (row
, w
->current_matrix
));
15249 xassert (w
->window_end_bytepos
>= 0);
15250 IF_DEBUG (debug_method_add (w
, "A"));
15252 else if (last_text_row_at_end
)
15255 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row_at_end
));
15256 w
->window_end_bytepos
15257 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row_at_end
);
15259 = make_number (MATRIX_ROW_VPOS (last_text_row_at_end
, desired_matrix
));
15260 xassert (w
->window_end_bytepos
>= 0);
15261 IF_DEBUG (debug_method_add (w
, "B"));
15263 else if (last_text_row
)
15265 /* We have displayed either to the end of the window or at the
15266 end of the window, i.e. the last row with text is to be found
15267 in the desired matrix. */
15269 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
15270 w
->window_end_bytepos
15271 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
15273 = make_number (MATRIX_ROW_VPOS (last_text_row
, desired_matrix
));
15274 xassert (w
->window_end_bytepos
>= 0);
15276 else if (first_unchanged_at_end_row
== NULL
15277 && last_text_row
== NULL
15278 && last_text_row_at_end
== NULL
)
15280 /* Displayed to end of window, but no line containing text was
15281 displayed. Lines were deleted at the end of the window. */
15282 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
15283 int vpos
= XFASTINT (w
->window_end_vpos
);
15284 struct glyph_row
*current_row
= current_matrix
->rows
+ vpos
;
15285 struct glyph_row
*desired_row
= desired_matrix
->rows
+ vpos
;
15288 row
== NULL
&& vpos
>= first_vpos
;
15289 --vpos
, --current_row
, --desired_row
)
15291 if (desired_row
->enabled_p
)
15293 if (desired_row
->displays_text_p
)
15296 else if (current_row
->displays_text_p
)
15300 xassert (row
!= NULL
);
15301 w
->window_end_vpos
= make_number (vpos
+ 1);
15302 w
->window_end_pos
= make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
15303 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
15304 xassert (w
->window_end_bytepos
>= 0);
15305 IF_DEBUG (debug_method_add (w
, "C"));
15310 #if 0 /* This leads to problems, for instance when the cursor is
15311 at ZV, and the cursor line displays no text. */
15312 /* Disable rows below what's displayed in the window. This makes
15313 debugging easier. */
15314 enable_glyph_matrix_rows (current_matrix
,
15315 XFASTINT (w
->window_end_vpos
) + 1,
15319 IF_DEBUG (debug_end_pos
= XFASTINT (w
->window_end_pos
);
15320 debug_end_vpos
= XFASTINT (w
->window_end_vpos
));
15322 /* Record that display has not been completed. */
15323 w
->window_end_valid
= Qnil
;
15324 w
->desired_matrix
->no_scrolling_p
= 1;
15332 /***********************************************************************
15333 More debugging support
15334 ***********************************************************************/
15338 void dump_glyph_row
P_ ((struct glyph_row
*, int, int));
15339 void dump_glyph_matrix
P_ ((struct glyph_matrix
*, int));
15340 void dump_glyph
P_ ((struct glyph_row
*, struct glyph
*, int));
15343 /* Dump the contents of glyph matrix MATRIX on stderr.
15345 GLYPHS 0 means don't show glyph contents.
15346 GLYPHS 1 means show glyphs in short form
15347 GLYPHS > 1 means show glyphs in long form. */
15350 dump_glyph_matrix (matrix
, glyphs
)
15351 struct glyph_matrix
*matrix
;
15355 for (i
= 0; i
< matrix
->nrows
; ++i
)
15356 dump_glyph_row (MATRIX_ROW (matrix
, i
), i
, glyphs
);
15360 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
15361 the glyph row and area where the glyph comes from. */
15364 dump_glyph (row
, glyph
, area
)
15365 struct glyph_row
*row
;
15366 struct glyph
*glyph
;
15369 if (glyph
->type
== CHAR_GLYPH
)
15372 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
15373 glyph
- row
->glyphs
[TEXT_AREA
],
15376 (BUFFERP (glyph
->object
)
15378 : (STRINGP (glyph
->object
)
15381 glyph
->pixel_width
,
15383 (glyph
->u
.ch
< 0x80 && glyph
->u
.ch
>= ' '
15387 glyph
->left_box_line_p
,
15388 glyph
->right_box_line_p
);
15390 else if (glyph
->type
== STRETCH_GLYPH
)
15393 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
15394 glyph
- row
->glyphs
[TEXT_AREA
],
15397 (BUFFERP (glyph
->object
)
15399 : (STRINGP (glyph
->object
)
15402 glyph
->pixel_width
,
15406 glyph
->left_box_line_p
,
15407 glyph
->right_box_line_p
);
15409 else if (glyph
->type
== IMAGE_GLYPH
)
15412 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
15413 glyph
- row
->glyphs
[TEXT_AREA
],
15416 (BUFFERP (glyph
->object
)
15418 : (STRINGP (glyph
->object
)
15421 glyph
->pixel_width
,
15425 glyph
->left_box_line_p
,
15426 glyph
->right_box_line_p
);
15428 else if (glyph
->type
== COMPOSITE_GLYPH
)
15431 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
15432 glyph
- row
->glyphs
[TEXT_AREA
],
15435 (BUFFERP (glyph
->object
)
15437 : (STRINGP (glyph
->object
)
15440 glyph
->pixel_width
,
15444 glyph
->left_box_line_p
,
15445 glyph
->right_box_line_p
);
15450 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
15451 GLYPHS 0 means don't show glyph contents.
15452 GLYPHS 1 means show glyphs in short form
15453 GLYPHS > 1 means show glyphs in long form. */
15456 dump_glyph_row (row
, vpos
, glyphs
)
15457 struct glyph_row
*row
;
15462 fprintf (stderr
, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
15463 fprintf (stderr
, "======================================================================\n");
15465 fprintf (stderr
, "%3d %5d %5d %4d %1.1d%1.1d%1.1d%1.1d\
15466 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
15468 MATRIX_ROW_START_CHARPOS (row
),
15469 MATRIX_ROW_END_CHARPOS (row
),
15470 row
->used
[TEXT_AREA
],
15471 row
->contains_overlapping_glyphs_p
,
15473 row
->truncated_on_left_p
,
15474 row
->truncated_on_right_p
,
15476 MATRIX_ROW_CONTINUATION_LINE_P (row
),
15477 row
->displays_text_p
,
15480 row
->ends_in_middle_of_char_p
,
15481 row
->starts_in_middle_of_char_p
,
15487 row
->visible_height
,
15490 fprintf (stderr
, "%9d %5d\t%5d\n", row
->start
.overlay_string_index
,
15491 row
->end
.overlay_string_index
,
15492 row
->continuation_lines_width
);
15493 fprintf (stderr
, "%9d %5d\n",
15494 CHARPOS (row
->start
.string_pos
),
15495 CHARPOS (row
->end
.string_pos
));
15496 fprintf (stderr
, "%9d %5d\n", row
->start
.dpvec_index
,
15497 row
->end
.dpvec_index
);
15504 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
15506 struct glyph
*glyph
= row
->glyphs
[area
];
15507 struct glyph
*glyph_end
= glyph
+ row
->used
[area
];
15509 /* Glyph for a line end in text. */
15510 if (area
== TEXT_AREA
&& glyph
== glyph_end
&& glyph
->charpos
> 0)
15513 if (glyph
< glyph_end
)
15514 fprintf (stderr
, " Glyph Type Pos O W Code C Face LR\n");
15516 for (; glyph
< glyph_end
; ++glyph
)
15517 dump_glyph (row
, glyph
, area
);
15520 else if (glyphs
== 1)
15524 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
15526 char *s
= (char *) alloca (row
->used
[area
] + 1);
15529 for (i
= 0; i
< row
->used
[area
]; ++i
)
15531 struct glyph
*glyph
= row
->glyphs
[area
] + i
;
15532 if (glyph
->type
== CHAR_GLYPH
15533 && glyph
->u
.ch
< 0x80
15534 && glyph
->u
.ch
>= ' ')
15535 s
[i
] = glyph
->u
.ch
;
15541 fprintf (stderr
, "%3d: (%d) '%s'\n", vpos
, row
->enabled_p
, s
);
15547 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix
,
15548 Sdump_glyph_matrix
, 0, 1, "p",
15549 doc
: /* Dump the current matrix of the selected window to stderr.
15550 Shows contents of glyph row structures. With non-nil
15551 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
15552 glyphs in short form, otherwise show glyphs in long form. */)
15554 Lisp_Object glyphs
;
15556 struct window
*w
= XWINDOW (selected_window
);
15557 struct buffer
*buffer
= XBUFFER (w
->buffer
);
15559 fprintf (stderr
, "PT = %d, BEGV = %d. ZV = %d\n",
15560 BUF_PT (buffer
), BUF_BEGV (buffer
), BUF_ZV (buffer
));
15561 fprintf (stderr
, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
15562 w
->cursor
.x
, w
->cursor
.y
, w
->cursor
.hpos
, w
->cursor
.vpos
);
15563 fprintf (stderr
, "=============================================\n");
15564 dump_glyph_matrix (w
->current_matrix
,
15565 NILP (glyphs
) ? 0 : XINT (glyphs
));
15570 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix
,
15571 Sdump_frame_glyph_matrix
, 0, 0, "", doc
: /* */)
15574 struct frame
*f
= XFRAME (selected_frame
);
15575 dump_glyph_matrix (f
->current_matrix
, 1);
15580 DEFUN ("dump-glyph-row", Fdump_glyph_row
, Sdump_glyph_row
, 1, 2, "",
15581 doc
: /* Dump glyph row ROW to stderr.
15582 GLYPH 0 means don't dump glyphs.
15583 GLYPH 1 means dump glyphs in short form.
15584 GLYPH > 1 or omitted means dump glyphs in long form. */)
15586 Lisp_Object row
, glyphs
;
15588 struct glyph_matrix
*matrix
;
15591 CHECK_NUMBER (row
);
15592 matrix
= XWINDOW (selected_window
)->current_matrix
;
15594 if (vpos
>= 0 && vpos
< matrix
->nrows
)
15595 dump_glyph_row (MATRIX_ROW (matrix
, vpos
),
15597 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
15602 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row
, Sdump_tool_bar_row
, 1, 2, "",
15603 doc
: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
15604 GLYPH 0 means don't dump glyphs.
15605 GLYPH 1 means dump glyphs in short form.
15606 GLYPH > 1 or omitted means dump glyphs in long form. */)
15608 Lisp_Object row
, glyphs
;
15610 struct frame
*sf
= SELECTED_FRAME ();
15611 struct glyph_matrix
*m
= XWINDOW (sf
->tool_bar_window
)->current_matrix
;
15614 CHECK_NUMBER (row
);
15616 if (vpos
>= 0 && vpos
< m
->nrows
)
15617 dump_glyph_row (MATRIX_ROW (m
, vpos
), vpos
,
15618 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
15623 DEFUN ("trace-redisplay", Ftrace_redisplay
, Strace_redisplay
, 0, 1, "P",
15624 doc
: /* Toggle tracing of redisplay.
15625 With ARG, turn tracing on if and only if ARG is positive. */)
15630 trace_redisplay_p
= !trace_redisplay_p
;
15633 arg
= Fprefix_numeric_value (arg
);
15634 trace_redisplay_p
= XINT (arg
) > 0;
15641 DEFUN ("trace-to-stderr", Ftrace_to_stderr
, Strace_to_stderr
, 1, MANY
, "",
15642 doc
: /* Like `format', but print result to stderr.
15643 usage: (trace-to-stderr STRING &rest OBJECTS) */)
15648 Lisp_Object s
= Fformat (nargs
, args
);
15649 fprintf (stderr
, "%s", SDATA (s
));
15653 #endif /* GLYPH_DEBUG */
15657 /***********************************************************************
15658 Building Desired Matrix Rows
15659 ***********************************************************************/
15661 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
15662 Used for non-window-redisplay windows, and for windows w/o left fringe. */
15664 static struct glyph_row
*
15665 get_overlay_arrow_glyph_row (w
, overlay_arrow_string
)
15667 Lisp_Object overlay_arrow_string
;
15669 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
15670 struct buffer
*buffer
= XBUFFER (w
->buffer
);
15671 struct buffer
*old
= current_buffer
;
15672 const unsigned char *arrow_string
= SDATA (overlay_arrow_string
);
15673 int arrow_len
= SCHARS (overlay_arrow_string
);
15674 const unsigned char *arrow_end
= arrow_string
+ arrow_len
;
15675 const unsigned char *p
;
15678 int n_glyphs_before
;
15680 set_buffer_temp (buffer
);
15681 init_iterator (&it
, w
, -1, -1, &scratch_glyph_row
, DEFAULT_FACE_ID
);
15682 it
.glyph_row
->used
[TEXT_AREA
] = 0;
15683 SET_TEXT_POS (it
.position
, 0, 0);
15685 multibyte_p
= !NILP (buffer
->enable_multibyte_characters
);
15687 while (p
< arrow_end
)
15689 Lisp_Object face
, ilisp
;
15691 /* Get the next character. */
15693 it
.c
= string_char_and_length (p
, arrow_len
, &it
.len
);
15695 it
.c
= *p
, it
.len
= 1;
15698 /* Get its face. */
15699 ilisp
= make_number (p
- arrow_string
);
15700 face
= Fget_text_property (ilisp
, Qface
, overlay_arrow_string
);
15701 it
.face_id
= compute_char_face (f
, it
.c
, face
);
15703 /* Compute its width, get its glyphs. */
15704 n_glyphs_before
= it
.glyph_row
->used
[TEXT_AREA
];
15705 SET_TEXT_POS (it
.position
, -1, -1);
15706 PRODUCE_GLYPHS (&it
);
15708 /* If this character doesn't fit any more in the line, we have
15709 to remove some glyphs. */
15710 if (it
.current_x
> it
.last_visible_x
)
15712 it
.glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
15717 set_buffer_temp (old
);
15718 return it
.glyph_row
;
15722 /* Insert truncation glyphs at the start of IT->glyph_row. Truncation
15723 glyphs are only inserted for terminal frames since we can't really
15724 win with truncation glyphs when partially visible glyphs are
15725 involved. Which glyphs to insert is determined by
15726 produce_special_glyphs. */
15729 insert_left_trunc_glyphs (it
)
15732 struct it truncate_it
;
15733 struct glyph
*from
, *end
, *to
, *toend
;
15735 xassert (!FRAME_WINDOW_P (it
->f
));
15737 /* Get the truncation glyphs. */
15739 truncate_it
.current_x
= 0;
15740 truncate_it
.face_id
= DEFAULT_FACE_ID
;
15741 truncate_it
.glyph_row
= &scratch_glyph_row
;
15742 truncate_it
.glyph_row
->used
[TEXT_AREA
] = 0;
15743 CHARPOS (truncate_it
.position
) = BYTEPOS (truncate_it
.position
) = -1;
15744 truncate_it
.object
= make_number (0);
15745 produce_special_glyphs (&truncate_it
, IT_TRUNCATION
);
15747 /* Overwrite glyphs from IT with truncation glyphs. */
15748 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
15749 end
= from
+ truncate_it
.glyph_row
->used
[TEXT_AREA
];
15750 to
= it
->glyph_row
->glyphs
[TEXT_AREA
];
15751 toend
= to
+ it
->glyph_row
->used
[TEXT_AREA
];
15756 /* There may be padding glyphs left over. Overwrite them too. */
15757 while (to
< toend
&& CHAR_GLYPH_PADDING_P (*to
))
15759 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
15765 it
->glyph_row
->used
[TEXT_AREA
] = to
- it
->glyph_row
->glyphs
[TEXT_AREA
];
15769 /* Compute the pixel height and width of IT->glyph_row.
15771 Most of the time, ascent and height of a display line will be equal
15772 to the max_ascent and max_height values of the display iterator
15773 structure. This is not the case if
15775 1. We hit ZV without displaying anything. In this case, max_ascent
15776 and max_height will be zero.
15778 2. We have some glyphs that don't contribute to the line height.
15779 (The glyph row flag contributes_to_line_height_p is for future
15780 pixmap extensions).
15782 The first case is easily covered by using default values because in
15783 these cases, the line height does not really matter, except that it
15784 must not be zero. */
15787 compute_line_metrics (it
)
15790 struct glyph_row
*row
= it
->glyph_row
;
15793 if (FRAME_WINDOW_P (it
->f
))
15795 int i
, min_y
, max_y
;
15797 /* The line may consist of one space only, that was added to
15798 place the cursor on it. If so, the row's height hasn't been
15800 if (row
->height
== 0)
15802 if (it
->max_ascent
+ it
->max_descent
== 0)
15803 it
->max_descent
= it
->max_phys_descent
= FRAME_LINE_HEIGHT (it
->f
);
15804 row
->ascent
= it
->max_ascent
;
15805 row
->height
= it
->max_ascent
+ it
->max_descent
;
15806 row
->phys_ascent
= it
->max_phys_ascent
;
15807 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
15808 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
15811 /* Compute the width of this line. */
15812 row
->pixel_width
= row
->x
;
15813 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
15814 row
->pixel_width
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
15816 xassert (row
->pixel_width
>= 0);
15817 xassert (row
->ascent
>= 0 && row
->height
> 0);
15819 row
->overlapping_p
= (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
15820 || MATRIX_ROW_OVERLAPS_PRED_P (row
));
15822 /* If first line's physical ascent is larger than its logical
15823 ascent, use the physical ascent, and make the row taller.
15824 This makes accented characters fully visible. */
15825 if (row
== MATRIX_FIRST_TEXT_ROW (it
->w
->desired_matrix
)
15826 && row
->phys_ascent
> row
->ascent
)
15828 row
->height
+= row
->phys_ascent
- row
->ascent
;
15829 row
->ascent
= row
->phys_ascent
;
15832 /* Compute how much of the line is visible. */
15833 row
->visible_height
= row
->height
;
15835 min_y
= WINDOW_HEADER_LINE_HEIGHT (it
->w
);
15836 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
);
15838 if (row
->y
< min_y
)
15839 row
->visible_height
-= min_y
- row
->y
;
15840 if (row
->y
+ row
->height
> max_y
)
15841 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
15845 row
->pixel_width
= row
->used
[TEXT_AREA
];
15846 if (row
->continued_p
)
15847 row
->pixel_width
-= it
->continuation_pixel_width
;
15848 else if (row
->truncated_on_right_p
)
15849 row
->pixel_width
-= it
->truncation_pixel_width
;
15850 row
->ascent
= row
->phys_ascent
= 0;
15851 row
->height
= row
->phys_height
= row
->visible_height
= 1;
15852 row
->extra_line_spacing
= 0;
15855 /* Compute a hash code for this row. */
15857 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
15858 for (i
= 0; i
< row
->used
[area
]; ++i
)
15859 row
->hash
= ((((row
->hash
<< 4) + (row
->hash
>> 24)) & 0x0fffffff)
15860 + row
->glyphs
[area
][i
].u
.val
15861 + row
->glyphs
[area
][i
].face_id
15862 + row
->glyphs
[area
][i
].padding_p
15863 + (row
->glyphs
[area
][i
].type
<< 2));
15865 it
->max_ascent
= it
->max_descent
= 0;
15866 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
15870 /* Append one space to the glyph row of iterator IT if doing a
15871 window-based redisplay. The space has the same face as
15872 IT->face_id. Value is non-zero if a space was added.
15874 This function is called to make sure that there is always one glyph
15875 at the end of a glyph row that the cursor can be set on under
15876 window-systems. (If there weren't such a glyph we would not know
15877 how wide and tall a box cursor should be displayed).
15879 At the same time this space let's a nicely handle clearing to the
15880 end of the line if the row ends in italic text. */
15883 append_space_for_newline (it
, default_face_p
)
15885 int default_face_p
;
15887 if (FRAME_WINDOW_P (it
->f
))
15889 int n
= it
->glyph_row
->used
[TEXT_AREA
];
15891 if (it
->glyph_row
->glyphs
[TEXT_AREA
] + n
15892 < it
->glyph_row
->glyphs
[1 + TEXT_AREA
])
15894 /* Save some values that must not be changed.
15895 Must save IT->c and IT->len because otherwise
15896 ITERATOR_AT_END_P wouldn't work anymore after
15897 append_space_for_newline has been called. */
15898 enum display_element_type saved_what
= it
->what
;
15899 int saved_c
= it
->c
, saved_len
= it
->len
;
15900 int saved_x
= it
->current_x
;
15901 int saved_face_id
= it
->face_id
;
15902 struct text_pos saved_pos
;
15903 Lisp_Object saved_object
;
15906 saved_object
= it
->object
;
15907 saved_pos
= it
->position
;
15909 it
->what
= IT_CHARACTER
;
15910 bzero (&it
->position
, sizeof it
->position
);
15911 it
->object
= make_number (0);
15915 if (default_face_p
)
15916 it
->face_id
= DEFAULT_FACE_ID
;
15917 else if (it
->face_before_selective_p
)
15918 it
->face_id
= it
->saved_face_id
;
15919 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
15920 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, 0, -1, Qnil
);
15922 PRODUCE_GLYPHS (it
);
15924 it
->override_ascent
= -1;
15925 it
->constrain_row_ascent_descent_p
= 0;
15926 it
->current_x
= saved_x
;
15927 it
->object
= saved_object
;
15928 it
->position
= saved_pos
;
15929 it
->what
= saved_what
;
15930 it
->face_id
= saved_face_id
;
15931 it
->len
= saved_len
;
15941 /* Extend the face of the last glyph in the text area of IT->glyph_row
15942 to the end of the display line. Called from display_line.
15943 If the glyph row is empty, add a space glyph to it so that we
15944 know the face to draw. Set the glyph row flag fill_line_p. */
15947 extend_face_to_end_of_line (it
)
15951 struct frame
*f
= it
->f
;
15953 /* If line is already filled, do nothing. */
15954 if (it
->current_x
>= it
->last_visible_x
)
15957 /* Face extension extends the background and box of IT->face_id
15958 to the end of the line. If the background equals the background
15959 of the frame, we don't have to do anything. */
15960 if (it
->face_before_selective_p
)
15961 face
= FACE_FROM_ID (it
->f
, it
->saved_face_id
);
15963 face
= FACE_FROM_ID (f
, it
->face_id
);
15965 if (FRAME_WINDOW_P (f
)
15966 && it
->glyph_row
->displays_text_p
15967 && face
->box
== FACE_NO_BOX
15968 && face
->background
== FRAME_BACKGROUND_PIXEL (f
)
15972 /* Set the glyph row flag indicating that the face of the last glyph
15973 in the text area has to be drawn to the end of the text area. */
15974 it
->glyph_row
->fill_line_p
= 1;
15976 /* If current character of IT is not ASCII, make sure we have the
15977 ASCII face. This will be automatically undone the next time
15978 get_next_display_element returns a multibyte character. Note
15979 that the character will always be single byte in unibyte text. */
15980 if (!ASCII_CHAR_P (it
->c
))
15982 it
->face_id
= FACE_FOR_CHAR (f
, face
, 0, -1, Qnil
);
15985 if (FRAME_WINDOW_P (f
))
15987 /* If the row is empty, add a space with the current face of IT,
15988 so that we know which face to draw. */
15989 if (it
->glyph_row
->used
[TEXT_AREA
] == 0)
15991 it
->glyph_row
->glyphs
[TEXT_AREA
][0] = space_glyph
;
15992 it
->glyph_row
->glyphs
[TEXT_AREA
][0].face_id
= it
->face_id
;
15993 it
->glyph_row
->used
[TEXT_AREA
] = 1;
15998 /* Save some values that must not be changed. */
15999 int saved_x
= it
->current_x
;
16000 struct text_pos saved_pos
;
16001 Lisp_Object saved_object
;
16002 enum display_element_type saved_what
= it
->what
;
16003 int saved_face_id
= it
->face_id
;
16005 saved_object
= it
->object
;
16006 saved_pos
= it
->position
;
16008 it
->what
= IT_CHARACTER
;
16009 bzero (&it
->position
, sizeof it
->position
);
16010 it
->object
= make_number (0);
16013 it
->face_id
= face
->id
;
16015 PRODUCE_GLYPHS (it
);
16017 while (it
->current_x
<= it
->last_visible_x
)
16018 PRODUCE_GLYPHS (it
);
16020 /* Don't count these blanks really. It would let us insert a left
16021 truncation glyph below and make us set the cursor on them, maybe. */
16022 it
->current_x
= saved_x
;
16023 it
->object
= saved_object
;
16024 it
->position
= saved_pos
;
16025 it
->what
= saved_what
;
16026 it
->face_id
= saved_face_id
;
16031 /* Value is non-zero if text starting at CHARPOS in current_buffer is
16032 trailing whitespace. */
16035 trailing_whitespace_p (charpos
)
16038 int bytepos
= CHAR_TO_BYTE (charpos
);
16041 while (bytepos
< ZV_BYTE
16042 && (c
= FETCH_CHAR (bytepos
),
16043 c
== ' ' || c
== '\t'))
16046 if (bytepos
>= ZV_BYTE
|| c
== '\n' || c
== '\r')
16048 if (bytepos
!= PT_BYTE
)
16055 /* Highlight trailing whitespace, if any, in ROW. */
16058 highlight_trailing_whitespace (f
, row
)
16060 struct glyph_row
*row
;
16062 int used
= row
->used
[TEXT_AREA
];
16066 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
16067 struct glyph
*glyph
= start
+ used
- 1;
16069 /* Skip over glyphs inserted to display the cursor at the
16070 end of a line, for extending the face of the last glyph
16071 to the end of the line on terminals, and for truncation
16072 and continuation glyphs. */
16073 while (glyph
>= start
16074 && glyph
->type
== CHAR_GLYPH
16075 && INTEGERP (glyph
->object
))
16078 /* If last glyph is a space or stretch, and it's trailing
16079 whitespace, set the face of all trailing whitespace glyphs in
16080 IT->glyph_row to `trailing-whitespace'. */
16082 && BUFFERP (glyph
->object
)
16083 && (glyph
->type
== STRETCH_GLYPH
16084 || (glyph
->type
== CHAR_GLYPH
16085 && glyph
->u
.ch
== ' '))
16086 && trailing_whitespace_p (glyph
->charpos
))
16088 int face_id
= lookup_named_face (f
, Qtrailing_whitespace
, 0);
16092 while (glyph
>= start
16093 && BUFFERP (glyph
->object
)
16094 && (glyph
->type
== STRETCH_GLYPH
16095 || (glyph
->type
== CHAR_GLYPH
16096 && glyph
->u
.ch
== ' ')))
16097 (glyph
--)->face_id
= face_id
;
16103 /* Value is non-zero if glyph row ROW in window W should be
16104 used to hold the cursor. */
16107 cursor_row_p (w
, row
)
16109 struct glyph_row
*row
;
16111 int cursor_row_p
= 1;
16113 if (PT
== MATRIX_ROW_END_CHARPOS (row
))
16115 /* Suppose the row ends on a string.
16116 Unless the row is continued, that means it ends on a newline
16117 in the string. If it's anything other than a display string
16118 (e.g. a before-string from an overlay), we don't want the
16119 cursor there. (This heuristic seems to give the optimal
16120 behavior for the various types of multi-line strings.) */
16121 if (CHARPOS (row
->end
.string_pos
) >= 0)
16123 if (row
->continued_p
)
16127 /* Check for `display' property. */
16128 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
16129 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
] - 1;
16130 struct glyph
*glyph
;
16133 for (glyph
= end
; glyph
>= beg
; --glyph
)
16134 if (STRINGP (glyph
->object
))
16137 = Fget_char_property (make_number (PT
),
16141 && display_prop_string_p (prop
, glyph
->object
));
16146 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
16148 /* If the row ends in middle of a real character,
16149 and the line is continued, we want the cursor here.
16150 That's because MATRIX_ROW_END_CHARPOS would equal
16151 PT if PT is before the character. */
16152 if (!row
->ends_in_ellipsis_p
)
16153 cursor_row_p
= row
->continued_p
;
16155 /* If the row ends in an ellipsis, then
16156 MATRIX_ROW_END_CHARPOS will equal point after the invisible text.
16157 We want that position to be displayed after the ellipsis. */
16160 /* If the row ends at ZV, display the cursor at the end of that
16161 row instead of at the start of the row below. */
16162 else if (row
->ends_at_zv_p
)
16168 return cursor_row_p
;
16172 /* Construct the glyph row IT->glyph_row in the desired matrix of
16173 IT->w from text at the current position of IT. See dispextern.h
16174 for an overview of struct it. Value is non-zero if
16175 IT->glyph_row displays text, as opposed to a line displaying ZV
16182 struct glyph_row
*row
= it
->glyph_row
;
16183 Lisp_Object overlay_arrow_string
;
16185 /* We always start displaying at hpos zero even if hscrolled. */
16186 xassert (it
->hpos
== 0 && it
->current_x
== 0);
16188 if (MATRIX_ROW_VPOS (row
, it
->w
->desired_matrix
)
16189 >= it
->w
->desired_matrix
->nrows
)
16191 it
->w
->nrows_scale_factor
++;
16192 fonts_changed_p
= 1;
16196 /* Is IT->w showing the region? */
16197 it
->w
->region_showing
= it
->region_beg_charpos
> 0 ? Qt
: Qnil
;
16199 /* Clear the result glyph row and enable it. */
16200 prepare_desired_row (row
);
16202 row
->y
= it
->current_y
;
16203 row
->start
= it
->start
;
16204 row
->continuation_lines_width
= it
->continuation_lines_width
;
16205 row
->displays_text_p
= 1;
16206 row
->starts_in_middle_of_char_p
= it
->starts_in_middle_of_char_p
;
16207 it
->starts_in_middle_of_char_p
= 0;
16209 /* Arrange the overlays nicely for our purposes. Usually, we call
16210 display_line on only one line at a time, in which case this
16211 can't really hurt too much, or we call it on lines which appear
16212 one after another in the buffer, in which case all calls to
16213 recenter_overlay_lists but the first will be pretty cheap. */
16214 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
16216 /* Move over display elements that are not visible because we are
16217 hscrolled. This may stop at an x-position < IT->first_visible_x
16218 if the first glyph is partially visible or if we hit a line end. */
16219 if (it
->current_x
< it
->first_visible_x
)
16221 move_it_in_display_line_to (it
, ZV
, it
->first_visible_x
,
16222 MOVE_TO_POS
| MOVE_TO_X
);
16225 /* Get the initial row height. This is either the height of the
16226 text hscrolled, if there is any, or zero. */
16227 row
->ascent
= it
->max_ascent
;
16228 row
->height
= it
->max_ascent
+ it
->max_descent
;
16229 row
->phys_ascent
= it
->max_phys_ascent
;
16230 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
16231 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
16233 /* Loop generating characters. The loop is left with IT on the next
16234 character to display. */
16237 int n_glyphs_before
, hpos_before
, x_before
;
16239 int ascent
= 0, descent
= 0, phys_ascent
= 0, phys_descent
= 0;
16241 /* Retrieve the next thing to display. Value is zero if end of
16243 if (!get_next_display_element (it
))
16245 /* Maybe add a space at the end of this line that is used to
16246 display the cursor there under X. Set the charpos of the
16247 first glyph of blank lines not corresponding to any text
16249 #ifdef HAVE_WINDOW_SYSTEM
16250 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
16251 row
->exact_window_width_line_p
= 1;
16253 #endif /* HAVE_WINDOW_SYSTEM */
16254 if ((append_space_for_newline (it
, 1) && row
->used
[TEXT_AREA
] == 1)
16255 || row
->used
[TEXT_AREA
] == 0)
16257 row
->glyphs
[TEXT_AREA
]->charpos
= -1;
16258 row
->displays_text_p
= 0;
16260 if (!NILP (XBUFFER (it
->w
->buffer
)->indicate_empty_lines
)
16261 && (!MINI_WINDOW_P (it
->w
)
16262 || (minibuf_level
&& EQ (it
->window
, minibuf_window
))))
16263 row
->indicate_empty_line_p
= 1;
16266 it
->continuation_lines_width
= 0;
16267 row
->ends_at_zv_p
= 1;
16271 /* Now, get the metrics of what we want to display. This also
16272 generates glyphs in `row' (which is IT->glyph_row). */
16273 n_glyphs_before
= row
->used
[TEXT_AREA
];
16276 /* Remember the line height so far in case the next element doesn't
16277 fit on the line. */
16278 if (!it
->truncate_lines_p
)
16280 ascent
= it
->max_ascent
;
16281 descent
= it
->max_descent
;
16282 phys_ascent
= it
->max_phys_ascent
;
16283 phys_descent
= it
->max_phys_descent
;
16286 PRODUCE_GLYPHS (it
);
16288 /* If this display element was in marginal areas, continue with
16290 if (it
->area
!= TEXT_AREA
)
16292 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
16293 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
16294 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
16295 row
->phys_height
= max (row
->phys_height
,
16296 it
->max_phys_ascent
+ it
->max_phys_descent
);
16297 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
16298 it
->max_extra_line_spacing
);
16299 set_iterator_to_next (it
, 1);
16303 /* Does the display element fit on the line? If we truncate
16304 lines, we should draw past the right edge of the window. If
16305 we don't truncate, we want to stop so that we can display the
16306 continuation glyph before the right margin. If lines are
16307 continued, there are two possible strategies for characters
16308 resulting in more than 1 glyph (e.g. tabs): Display as many
16309 glyphs as possible in this line and leave the rest for the
16310 continuation line, or display the whole element in the next
16311 line. Original redisplay did the former, so we do it also. */
16312 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
16313 hpos_before
= it
->hpos
;
16316 if (/* Not a newline. */
16318 /* Glyphs produced fit entirely in the line. */
16319 && it
->current_x
< it
->last_visible_x
)
16321 it
->hpos
+= nglyphs
;
16322 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
16323 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
16324 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
16325 row
->phys_height
= max (row
->phys_height
,
16326 it
->max_phys_ascent
+ it
->max_phys_descent
);
16327 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
16328 it
->max_extra_line_spacing
);
16329 if (it
->current_x
- it
->pixel_width
< it
->first_visible_x
)
16330 row
->x
= x
- it
->first_visible_x
;
16335 struct glyph
*glyph
;
16337 for (i
= 0; i
< nglyphs
; ++i
, x
= new_x
)
16339 glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
16340 new_x
= x
+ glyph
->pixel_width
;
16342 if (/* Lines are continued. */
16343 !it
->truncate_lines_p
16344 && (/* Glyph doesn't fit on the line. */
16345 new_x
> it
->last_visible_x
16346 /* Or it fits exactly on a window system frame. */
16347 || (new_x
== it
->last_visible_x
16348 && FRAME_WINDOW_P (it
->f
))))
16350 /* End of a continued line. */
16353 || (new_x
== it
->last_visible_x
16354 && FRAME_WINDOW_P (it
->f
)))
16356 /* Current glyph is the only one on the line or
16357 fits exactly on the line. We must continue
16358 the line because we can't draw the cursor
16359 after the glyph. */
16360 row
->continued_p
= 1;
16361 it
->current_x
= new_x
;
16362 it
->continuation_lines_width
+= new_x
;
16364 if (i
== nglyphs
- 1)
16366 set_iterator_to_next (it
, 1);
16367 #ifdef HAVE_WINDOW_SYSTEM
16368 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
16370 if (!get_next_display_element (it
))
16372 row
->exact_window_width_line_p
= 1;
16373 it
->continuation_lines_width
= 0;
16374 row
->continued_p
= 0;
16375 row
->ends_at_zv_p
= 1;
16377 else if (ITERATOR_AT_END_OF_LINE_P (it
))
16379 row
->continued_p
= 0;
16380 row
->exact_window_width_line_p
= 1;
16383 #endif /* HAVE_WINDOW_SYSTEM */
16386 else if (CHAR_GLYPH_PADDING_P (*glyph
)
16387 && !FRAME_WINDOW_P (it
->f
))
16389 /* A padding glyph that doesn't fit on this line.
16390 This means the whole character doesn't fit
16392 row
->used
[TEXT_AREA
] = n_glyphs_before
;
16394 /* Fill the rest of the row with continuation
16395 glyphs like in 20.x. */
16396 while (row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
]
16397 < row
->glyphs
[1 + TEXT_AREA
])
16398 produce_special_glyphs (it
, IT_CONTINUATION
);
16400 row
->continued_p
= 1;
16401 it
->current_x
= x_before
;
16402 it
->continuation_lines_width
+= x_before
;
16404 /* Restore the height to what it was before the
16405 element not fitting on the line. */
16406 it
->max_ascent
= ascent
;
16407 it
->max_descent
= descent
;
16408 it
->max_phys_ascent
= phys_ascent
;
16409 it
->max_phys_descent
= phys_descent
;
16411 else if (it
->c
== '\t' && FRAME_WINDOW_P (it
->f
))
16413 /* A TAB that extends past the right edge of the
16414 window. This produces a single glyph on
16415 window system frames. We leave the glyph in
16416 this row and let it fill the row, but don't
16417 consume the TAB. */
16418 it
->continuation_lines_width
+= it
->last_visible_x
;
16419 row
->ends_in_middle_of_char_p
= 1;
16420 row
->continued_p
= 1;
16421 glyph
->pixel_width
= it
->last_visible_x
- x
;
16422 it
->starts_in_middle_of_char_p
= 1;
16426 /* Something other than a TAB that draws past
16427 the right edge of the window. Restore
16428 positions to values before the element. */
16429 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
16431 /* Display continuation glyphs. */
16432 if (!FRAME_WINDOW_P (it
->f
))
16433 produce_special_glyphs (it
, IT_CONTINUATION
);
16434 row
->continued_p
= 1;
16436 it
->current_x
= x_before
;
16437 it
->continuation_lines_width
+= x
;
16438 extend_face_to_end_of_line (it
);
16440 if (nglyphs
> 1 && i
> 0)
16442 row
->ends_in_middle_of_char_p
= 1;
16443 it
->starts_in_middle_of_char_p
= 1;
16446 /* Restore the height to what it was before the
16447 element not fitting on the line. */
16448 it
->max_ascent
= ascent
;
16449 it
->max_descent
= descent
;
16450 it
->max_phys_ascent
= phys_ascent
;
16451 it
->max_phys_descent
= phys_descent
;
16456 else if (new_x
> it
->first_visible_x
)
16458 /* Increment number of glyphs actually displayed. */
16461 if (x
< it
->first_visible_x
)
16462 /* Glyph is partially visible, i.e. row starts at
16463 negative X position. */
16464 row
->x
= x
- it
->first_visible_x
;
16468 /* Glyph is completely off the left margin of the
16469 window. This should not happen because of the
16470 move_it_in_display_line at the start of this
16471 function, unless the text display area of the
16472 window is empty. */
16473 xassert (it
->first_visible_x
<= it
->last_visible_x
);
16477 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
16478 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
16479 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
16480 row
->phys_height
= max (row
->phys_height
,
16481 it
->max_phys_ascent
+ it
->max_phys_descent
);
16482 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
16483 it
->max_extra_line_spacing
);
16485 /* End of this display line if row is continued. */
16486 if (row
->continued_p
|| row
->ends_at_zv_p
)
16491 /* Is this a line end? If yes, we're also done, after making
16492 sure that a non-default face is extended up to the right
16493 margin of the window. */
16494 if (ITERATOR_AT_END_OF_LINE_P (it
))
16496 int used_before
= row
->used
[TEXT_AREA
];
16498 row
->ends_in_newline_from_string_p
= STRINGP (it
->object
);
16500 #ifdef HAVE_WINDOW_SYSTEM
16501 /* Add a space at the end of the line that is used to
16502 display the cursor there. */
16503 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
16504 append_space_for_newline (it
, 0);
16505 #endif /* HAVE_WINDOW_SYSTEM */
16507 /* Extend the face to the end of the line. */
16508 extend_face_to_end_of_line (it
);
16510 /* Make sure we have the position. */
16511 if (used_before
== 0)
16512 row
->glyphs
[TEXT_AREA
]->charpos
= CHARPOS (it
->position
);
16514 /* Consume the line end. This skips over invisible lines. */
16515 set_iterator_to_next (it
, 1);
16516 it
->continuation_lines_width
= 0;
16520 /* Proceed with next display element. Note that this skips
16521 over lines invisible because of selective display. */
16522 set_iterator_to_next (it
, 1);
16524 /* If we truncate lines, we are done when the last displayed
16525 glyphs reach past the right margin of the window. */
16526 if (it
->truncate_lines_p
16527 && (FRAME_WINDOW_P (it
->f
)
16528 ? (it
->current_x
>= it
->last_visible_x
)
16529 : (it
->current_x
> it
->last_visible_x
)))
16531 /* Maybe add truncation glyphs. */
16532 if (!FRAME_WINDOW_P (it
->f
))
16536 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
16537 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
16540 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
16542 row
->used
[TEXT_AREA
] = i
;
16543 produce_special_glyphs (it
, IT_TRUNCATION
);
16546 #ifdef HAVE_WINDOW_SYSTEM
16549 /* Don't truncate if we can overflow newline into fringe. */
16550 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
16552 if (!get_next_display_element (it
))
16554 it
->continuation_lines_width
= 0;
16555 row
->ends_at_zv_p
= 1;
16556 row
->exact_window_width_line_p
= 1;
16559 if (ITERATOR_AT_END_OF_LINE_P (it
))
16561 row
->exact_window_width_line_p
= 1;
16562 goto at_end_of_line
;
16566 #endif /* HAVE_WINDOW_SYSTEM */
16568 row
->truncated_on_right_p
= 1;
16569 it
->continuation_lines_width
= 0;
16570 reseat_at_next_visible_line_start (it
, 0);
16571 row
->ends_at_zv_p
= FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n';
16572 it
->hpos
= hpos_before
;
16573 it
->current_x
= x_before
;
16578 /* If line is not empty and hscrolled, maybe insert truncation glyphs
16579 at the left window margin. */
16580 if (it
->first_visible_x
16581 && IT_CHARPOS (*it
) != MATRIX_ROW_START_CHARPOS (row
))
16583 if (!FRAME_WINDOW_P (it
->f
))
16584 insert_left_trunc_glyphs (it
);
16585 row
->truncated_on_left_p
= 1;
16588 /* If the start of this line is the overlay arrow-position, then
16589 mark this glyph row as the one containing the overlay arrow.
16590 This is clearly a mess with variable size fonts. It would be
16591 better to let it be displayed like cursors under X. */
16592 if ((row
->displays_text_p
|| !overlay_arrow_seen
)
16593 && (overlay_arrow_string
= overlay_arrow_at_row (it
, row
),
16594 !NILP (overlay_arrow_string
)))
16596 /* Overlay arrow in window redisplay is a fringe bitmap. */
16597 if (STRINGP (overlay_arrow_string
))
16599 struct glyph_row
*arrow_row
16600 = get_overlay_arrow_glyph_row (it
->w
, overlay_arrow_string
);
16601 struct glyph
*glyph
= arrow_row
->glyphs
[TEXT_AREA
];
16602 struct glyph
*arrow_end
= glyph
+ arrow_row
->used
[TEXT_AREA
];
16603 struct glyph
*p
= row
->glyphs
[TEXT_AREA
];
16604 struct glyph
*p2
, *end
;
16606 /* Copy the arrow glyphs. */
16607 while (glyph
< arrow_end
)
16610 /* Throw away padding glyphs. */
16612 end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
16613 while (p2
< end
&& CHAR_GLYPH_PADDING_P (*p2
))
16619 row
->used
[TEXT_AREA
] = p2
- row
->glyphs
[TEXT_AREA
];
16624 xassert (INTEGERP (overlay_arrow_string
));
16625 row
->overlay_arrow_bitmap
= XINT (overlay_arrow_string
);
16627 overlay_arrow_seen
= 1;
16630 /* Compute pixel dimensions of this line. */
16631 compute_line_metrics (it
);
16633 /* Remember the position at which this line ends. */
16634 row
->end
= it
->current
;
16636 /* Record whether this row ends inside an ellipsis. */
16637 row
->ends_in_ellipsis_p
16638 = (it
->method
== GET_FROM_DISPLAY_VECTOR
16639 && it
->ellipsis_p
);
16641 /* Save fringe bitmaps in this row. */
16642 row
->left_user_fringe_bitmap
= it
->left_user_fringe_bitmap
;
16643 row
->left_user_fringe_face_id
= it
->left_user_fringe_face_id
;
16644 row
->right_user_fringe_bitmap
= it
->right_user_fringe_bitmap
;
16645 row
->right_user_fringe_face_id
= it
->right_user_fringe_face_id
;
16647 it
->left_user_fringe_bitmap
= 0;
16648 it
->left_user_fringe_face_id
= 0;
16649 it
->right_user_fringe_bitmap
= 0;
16650 it
->right_user_fringe_face_id
= 0;
16652 /* Maybe set the cursor. */
16653 if (it
->w
->cursor
.vpos
< 0
16654 && PT
>= MATRIX_ROW_START_CHARPOS (row
)
16655 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
16656 && cursor_row_p (it
->w
, row
))
16657 set_cursor_from_row (it
->w
, row
, it
->w
->desired_matrix
, 0, 0, 0, 0);
16659 /* Highlight trailing whitespace. */
16660 if (!NILP (Vshow_trailing_whitespace
))
16661 highlight_trailing_whitespace (it
->f
, it
->glyph_row
);
16663 /* Prepare for the next line. This line starts horizontally at (X
16664 HPOS) = (0 0). Vertical positions are incremented. As a
16665 convenience for the caller, IT->glyph_row is set to the next
16667 it
->current_x
= it
->hpos
= 0;
16668 it
->current_y
+= row
->height
;
16671 it
->start
= it
->current
;
16672 return row
->displays_text_p
;
16677 /***********************************************************************
16679 ***********************************************************************/
16681 /* Redisplay the menu bar in the frame for window W.
16683 The menu bar of X frames that don't have X toolkit support is
16684 displayed in a special window W->frame->menu_bar_window.
16686 The menu bar of terminal frames is treated specially as far as
16687 glyph matrices are concerned. Menu bar lines are not part of
16688 windows, so the update is done directly on the frame matrix rows
16689 for the menu bar. */
16692 display_menu_bar (w
)
16695 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
16700 /* Don't do all this for graphical frames. */
16702 if (FRAME_W32_P (f
))
16705 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
16710 if (FRAME_MAC_P (f
))
16714 #ifdef USE_X_TOOLKIT
16715 xassert (!FRAME_WINDOW_P (f
));
16716 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
, MENU_FACE_ID
);
16717 it
.first_visible_x
= 0;
16718 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
16719 #else /* not USE_X_TOOLKIT */
16720 if (FRAME_WINDOW_P (f
))
16722 /* Menu bar lines are displayed in the desired matrix of the
16723 dummy window menu_bar_window. */
16724 struct window
*menu_w
;
16725 xassert (WINDOWP (f
->menu_bar_window
));
16726 menu_w
= XWINDOW (f
->menu_bar_window
);
16727 init_iterator (&it
, menu_w
, -1, -1, menu_w
->desired_matrix
->rows
,
16729 it
.first_visible_x
= 0;
16730 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
16734 /* This is a TTY frame, i.e. character hpos/vpos are used as
16736 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
,
16738 it
.first_visible_x
= 0;
16739 it
.last_visible_x
= FRAME_COLS (f
);
16741 #endif /* not USE_X_TOOLKIT */
16743 if (! mode_line_inverse_video
)
16744 /* Force the menu-bar to be displayed in the default face. */
16745 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
16747 /* Clear all rows of the menu bar. */
16748 for (i
= 0; i
< FRAME_MENU_BAR_LINES (f
); ++i
)
16750 struct glyph_row
*row
= it
.glyph_row
+ i
;
16751 clear_glyph_row (row
);
16752 row
->enabled_p
= 1;
16753 row
->full_width_p
= 1;
16756 /* Display all items of the menu bar. */
16757 items
= FRAME_MENU_BAR_ITEMS (it
.f
);
16758 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
16760 Lisp_Object string
;
16762 /* Stop at nil string. */
16763 string
= AREF (items
, i
+ 1);
16767 /* Remember where item was displayed. */
16768 AREF (items
, i
+ 3) = make_number (it
.hpos
);
16770 /* Display the item, pad with one space. */
16771 if (it
.current_x
< it
.last_visible_x
)
16772 display_string (NULL
, string
, Qnil
, 0, 0, &it
,
16773 SCHARS (string
) + 1, 0, 0, -1);
16776 /* Fill out the line with spaces. */
16777 if (it
.current_x
< it
.last_visible_x
)
16778 display_string ("", Qnil
, Qnil
, 0, 0, &it
, -1, 0, 0, -1);
16780 /* Compute the total height of the lines. */
16781 compute_line_metrics (&it
);
16786 /***********************************************************************
16788 ***********************************************************************/
16790 /* Redisplay mode lines in the window tree whose root is WINDOW. If
16791 FORCE is non-zero, redisplay mode lines unconditionally.
16792 Otherwise, redisplay only mode lines that are garbaged. Value is
16793 the number of windows whose mode lines were redisplayed. */
16796 redisplay_mode_lines (window
, force
)
16797 Lisp_Object window
;
16802 while (!NILP (window
))
16804 struct window
*w
= XWINDOW (window
);
16806 if (WINDOWP (w
->hchild
))
16807 nwindows
+= redisplay_mode_lines (w
->hchild
, force
);
16808 else if (WINDOWP (w
->vchild
))
16809 nwindows
+= redisplay_mode_lines (w
->vchild
, force
);
16811 || FRAME_GARBAGED_P (XFRAME (w
->frame
))
16812 || !MATRIX_MODE_LINE_ROW (w
->current_matrix
)->enabled_p
)
16814 struct text_pos lpoint
;
16815 struct buffer
*old
= current_buffer
;
16817 /* Set the window's buffer for the mode line display. */
16818 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
16819 set_buffer_internal_1 (XBUFFER (w
->buffer
));
16821 /* Point refers normally to the selected window. For any
16822 other window, set up appropriate value. */
16823 if (!EQ (window
, selected_window
))
16825 struct text_pos pt
;
16827 SET_TEXT_POS_FROM_MARKER (pt
, w
->pointm
);
16828 if (CHARPOS (pt
) < BEGV
)
16829 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
16830 else if (CHARPOS (pt
) > (ZV
- 1))
16831 TEMP_SET_PT_BOTH (ZV
, ZV_BYTE
);
16833 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
16836 /* Display mode lines. */
16837 clear_glyph_matrix (w
->desired_matrix
);
16838 if (display_mode_lines (w
))
16841 w
->must_be_updated_p
= 1;
16844 /* Restore old settings. */
16845 set_buffer_internal_1 (old
);
16846 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
16856 /* Display the mode and/or top line of window W. Value is the number
16857 of mode lines displayed. */
16860 display_mode_lines (w
)
16863 Lisp_Object old_selected_window
, old_selected_frame
;
16866 old_selected_frame
= selected_frame
;
16867 selected_frame
= w
->frame
;
16868 old_selected_window
= selected_window
;
16869 XSETWINDOW (selected_window
, w
);
16871 /* These will be set while the mode line specs are processed. */
16872 line_number_displayed
= 0;
16873 w
->column_number_displayed
= Qnil
;
16875 if (WINDOW_WANTS_MODELINE_P (w
))
16877 struct window
*sel_w
= XWINDOW (old_selected_window
);
16879 /* Select mode line face based on the real selected window. */
16880 display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID_3 (sel_w
, sel_w
, w
),
16881 current_buffer
->mode_line_format
);
16885 if (WINDOW_WANTS_HEADER_LINE_P (w
))
16887 display_mode_line (w
, HEADER_LINE_FACE_ID
,
16888 current_buffer
->header_line_format
);
16892 selected_frame
= old_selected_frame
;
16893 selected_window
= old_selected_window
;
16898 /* Display mode or top line of window W. FACE_ID specifies which line
16899 to display; it is either MODE_LINE_FACE_ID or HEADER_LINE_FACE_ID.
16900 FORMAT is the mode line format to display. Value is the pixel
16901 height of the mode line displayed. */
16904 display_mode_line (w
, face_id
, format
)
16906 enum face_id face_id
;
16907 Lisp_Object format
;
16911 int count
= SPECPDL_INDEX ();
16913 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
16914 /* Don't extend on a previously drawn mode-line.
16915 This may happen if called from pos_visible_p. */
16916 it
.glyph_row
->enabled_p
= 0;
16917 prepare_desired_row (it
.glyph_row
);
16919 it
.glyph_row
->mode_line_p
= 1;
16921 if (! mode_line_inverse_video
)
16922 /* Force the mode-line to be displayed in the default face. */
16923 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
16925 record_unwind_protect (unwind_format_mode_line
,
16926 format_mode_line_unwind_data (NULL
, 0));
16928 mode_line_target
= MODE_LINE_DISPLAY
;
16930 /* Temporarily make frame's keyboard the current kboard so that
16931 kboard-local variables in the mode_line_format will get the right
16933 push_kboard (FRAME_KBOARD (it
.f
));
16934 record_unwind_save_match_data ();
16935 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
16938 unbind_to (count
, Qnil
);
16940 /* Fill up with spaces. */
16941 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 10000, -1, -1, 0);
16943 compute_line_metrics (&it
);
16944 it
.glyph_row
->full_width_p
= 1;
16945 it
.glyph_row
->continued_p
= 0;
16946 it
.glyph_row
->truncated_on_left_p
= 0;
16947 it
.glyph_row
->truncated_on_right_p
= 0;
16949 /* Make a 3D mode-line have a shadow at its right end. */
16950 face
= FACE_FROM_ID (it
.f
, face_id
);
16951 extend_face_to_end_of_line (&it
);
16952 if (face
->box
!= FACE_NO_BOX
)
16954 struct glyph
*last
= (it
.glyph_row
->glyphs
[TEXT_AREA
]
16955 + it
.glyph_row
->used
[TEXT_AREA
] - 1);
16956 last
->right_box_line_p
= 1;
16959 return it
.glyph_row
->height
;
16962 /* Move element ELT in LIST to the front of LIST.
16963 Return the updated list. */
16966 move_elt_to_front (elt
, list
)
16967 Lisp_Object elt
, list
;
16969 register Lisp_Object tail
, prev
;
16970 register Lisp_Object tem
;
16974 while (CONSP (tail
))
16980 /* Splice out the link TAIL. */
16982 list
= XCDR (tail
);
16984 Fsetcdr (prev
, XCDR (tail
));
16986 /* Now make it the first. */
16987 Fsetcdr (tail
, list
);
16992 tail
= XCDR (tail
);
16996 /* Not found--return unchanged LIST. */
17000 /* Contribute ELT to the mode line for window IT->w. How it
17001 translates into text depends on its data type.
17003 IT describes the display environment in which we display, as usual.
17005 DEPTH is the depth in recursion. It is used to prevent
17006 infinite recursion here.
17008 FIELD_WIDTH is the number of characters the display of ELT should
17009 occupy in the mode line, and PRECISION is the maximum number of
17010 characters to display from ELT's representation. See
17011 display_string for details.
17013 Returns the hpos of the end of the text generated by ELT.
17015 PROPS is a property list to add to any string we encounter.
17017 If RISKY is nonzero, remove (disregard) any properties in any string
17018 we encounter, and ignore :eval and :propertize.
17020 The global variable `mode_line_target' determines whether the
17021 output is passed to `store_mode_line_noprop',
17022 `store_mode_line_string', or `display_string'. */
17025 display_mode_element (it
, depth
, field_width
, precision
, elt
, props
, risky
)
17028 int field_width
, precision
;
17029 Lisp_Object elt
, props
;
17032 int n
= 0, field
, prec
;
17037 elt
= build_string ("*too-deep*");
17041 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
17045 /* A string: output it and check for %-constructs within it. */
17049 if (SCHARS (elt
) > 0
17050 && (!NILP (props
) || risky
))
17052 Lisp_Object oprops
, aelt
;
17053 oprops
= Ftext_properties_at (make_number (0), elt
);
17055 /* If the starting string's properties are not what
17056 we want, translate the string. Also, if the string
17057 is risky, do that anyway. */
17059 if (NILP (Fequal (props
, oprops
)) || risky
)
17061 /* If the starting string has properties,
17062 merge the specified ones onto the existing ones. */
17063 if (! NILP (oprops
) && !risky
)
17067 oprops
= Fcopy_sequence (oprops
);
17069 while (CONSP (tem
))
17071 oprops
= Fplist_put (oprops
, XCAR (tem
),
17072 XCAR (XCDR (tem
)));
17073 tem
= XCDR (XCDR (tem
));
17078 aelt
= Fassoc (elt
, mode_line_proptrans_alist
);
17079 if (! NILP (aelt
) && !NILP (Fequal (props
, XCDR (aelt
))))
17081 /* AELT is what we want. Move it to the front
17082 without consing. */
17084 mode_line_proptrans_alist
17085 = move_elt_to_front (aelt
, mode_line_proptrans_alist
);
17091 /* If AELT has the wrong props, it is useless.
17092 so get rid of it. */
17094 mode_line_proptrans_alist
17095 = Fdelq (aelt
, mode_line_proptrans_alist
);
17097 elt
= Fcopy_sequence (elt
);
17098 Fset_text_properties (make_number (0), Flength (elt
),
17100 /* Add this item to mode_line_proptrans_alist. */
17101 mode_line_proptrans_alist
17102 = Fcons (Fcons (elt
, props
),
17103 mode_line_proptrans_alist
);
17104 /* Truncate mode_line_proptrans_alist
17105 to at most 50 elements. */
17106 tem
= Fnthcdr (make_number (50),
17107 mode_line_proptrans_alist
);
17109 XSETCDR (tem
, Qnil
);
17118 prec
= precision
- n
;
17119 switch (mode_line_target
)
17121 case MODE_LINE_NOPROP
:
17122 case MODE_LINE_TITLE
:
17123 n
+= store_mode_line_noprop (SDATA (elt
), -1, prec
);
17125 case MODE_LINE_STRING
:
17126 n
+= store_mode_line_string (NULL
, elt
, 1, 0, prec
, Qnil
);
17128 case MODE_LINE_DISPLAY
:
17129 n
+= display_string (NULL
, elt
, Qnil
, 0, 0, it
,
17130 0, prec
, 0, STRING_MULTIBYTE (elt
));
17137 /* Handle the non-literal case. */
17139 while ((precision
<= 0 || n
< precision
)
17140 && SREF (elt
, offset
) != 0
17141 && (mode_line_target
!= MODE_LINE_DISPLAY
17142 || it
->current_x
< it
->last_visible_x
))
17144 int last_offset
= offset
;
17146 /* Advance to end of string or next format specifier. */
17147 while ((c
= SREF (elt
, offset
++)) != '\0' && c
!= '%')
17150 if (offset
- 1 != last_offset
)
17152 int nchars
, nbytes
;
17154 /* Output to end of string or up to '%'. Field width
17155 is length of string. Don't output more than
17156 PRECISION allows us. */
17159 prec
= c_string_width (SDATA (elt
) + last_offset
,
17160 offset
- last_offset
, precision
- n
,
17163 switch (mode_line_target
)
17165 case MODE_LINE_NOPROP
:
17166 case MODE_LINE_TITLE
:
17167 n
+= store_mode_line_noprop (SDATA (elt
) + last_offset
, 0, prec
);
17169 case MODE_LINE_STRING
:
17171 int bytepos
= last_offset
;
17172 int charpos
= string_byte_to_char (elt
, bytepos
);
17173 int endpos
= (precision
<= 0
17174 ? string_byte_to_char (elt
, offset
)
17175 : charpos
+ nchars
);
17177 n
+= store_mode_line_string (NULL
,
17178 Fsubstring (elt
, make_number (charpos
),
17179 make_number (endpos
)),
17183 case MODE_LINE_DISPLAY
:
17185 int bytepos
= last_offset
;
17186 int charpos
= string_byte_to_char (elt
, bytepos
);
17188 if (precision
<= 0)
17189 nchars
= string_byte_to_char (elt
, offset
) - charpos
;
17190 n
+= display_string (NULL
, elt
, Qnil
, 0, charpos
,
17192 STRING_MULTIBYTE (elt
));
17197 else /* c == '%' */
17199 int percent_position
= offset
;
17201 /* Get the specified minimum width. Zero means
17204 while ((c
= SREF (elt
, offset
++)) >= '0' && c
<= '9')
17205 field
= field
* 10 + c
- '0';
17207 /* Don't pad beyond the total padding allowed. */
17208 if (field_width
- n
> 0 && field
> field_width
- n
)
17209 field
= field_width
- n
;
17211 /* Note that either PRECISION <= 0 or N < PRECISION. */
17212 prec
= precision
- n
;
17215 n
+= display_mode_element (it
, depth
, field
, prec
,
17216 Vglobal_mode_string
, props
,
17221 int bytepos
, charpos
;
17222 unsigned char *spec
;
17224 bytepos
= percent_position
;
17225 charpos
= (STRING_MULTIBYTE (elt
)
17226 ? string_byte_to_char (elt
, bytepos
)
17230 = decode_mode_spec (it
->w
, c
, field
, prec
, &multibyte
);
17232 switch (mode_line_target
)
17234 case MODE_LINE_NOPROP
:
17235 case MODE_LINE_TITLE
:
17236 n
+= store_mode_line_noprop (spec
, field
, prec
);
17238 case MODE_LINE_STRING
:
17240 int len
= strlen (spec
);
17241 Lisp_Object tem
= make_string (spec
, len
);
17242 props
= Ftext_properties_at (make_number (charpos
), elt
);
17243 /* Should only keep face property in props */
17244 n
+= store_mode_line_string (NULL
, tem
, 0, field
, prec
, props
);
17247 case MODE_LINE_DISPLAY
:
17249 int nglyphs_before
, nwritten
;
17251 nglyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
17252 nwritten
= display_string (spec
, Qnil
, elt
,
17257 /* Assign to the glyphs written above the
17258 string where the `%x' came from, position
17262 struct glyph
*glyph
17263 = (it
->glyph_row
->glyphs
[TEXT_AREA
]
17267 for (i
= 0; i
< nwritten
; ++i
)
17269 glyph
[i
].object
= elt
;
17270 glyph
[i
].charpos
= charpos
;
17287 /* A symbol: process the value of the symbol recursively
17288 as if it appeared here directly. Avoid error if symbol void.
17289 Special case: if value of symbol is a string, output the string
17292 register Lisp_Object tem
;
17294 /* If the variable is not marked as risky to set
17295 then its contents are risky to use. */
17296 if (NILP (Fget (elt
, Qrisky_local_variable
)))
17299 tem
= Fboundp (elt
);
17302 tem
= Fsymbol_value (elt
);
17303 /* If value is a string, output that string literally:
17304 don't check for % within it. */
17308 if (!EQ (tem
, elt
))
17310 /* Give up right away for nil or t. */
17320 register Lisp_Object car
, tem
;
17322 /* A cons cell: five distinct cases.
17323 If first element is :eval or :propertize, do something special.
17324 If first element is a string or a cons, process all the elements
17325 and effectively concatenate them.
17326 If first element is a negative number, truncate displaying cdr to
17327 at most that many characters. If positive, pad (with spaces)
17328 to at least that many characters.
17329 If first element is a symbol, process the cadr or caddr recursively
17330 according to whether the symbol's value is non-nil or nil. */
17332 if (EQ (car
, QCeval
))
17334 /* An element of the form (:eval FORM) means evaluate FORM
17335 and use the result as mode line elements. */
17340 if (CONSP (XCDR (elt
)))
17343 spec
= safe_eval (XCAR (XCDR (elt
)));
17344 n
+= display_mode_element (it
, depth
, field_width
- n
,
17345 precision
- n
, spec
, props
,
17349 else if (EQ (car
, QCpropertize
))
17351 /* An element of the form (:propertize ELT PROPS...)
17352 means display ELT but applying properties PROPS. */
17357 if (CONSP (XCDR (elt
)))
17358 n
+= display_mode_element (it
, depth
, field_width
- n
,
17359 precision
- n
, XCAR (XCDR (elt
)),
17360 XCDR (XCDR (elt
)), risky
);
17362 else if (SYMBOLP (car
))
17364 tem
= Fboundp (car
);
17368 /* elt is now the cdr, and we know it is a cons cell.
17369 Use its car if CAR has a non-nil value. */
17372 tem
= Fsymbol_value (car
);
17379 /* Symbol's value is nil (or symbol is unbound)
17380 Get the cddr of the original list
17381 and if possible find the caddr and use that. */
17385 else if (!CONSP (elt
))
17390 else if (INTEGERP (car
))
17392 register int lim
= XINT (car
);
17396 /* Negative int means reduce maximum width. */
17397 if (precision
<= 0)
17400 precision
= min (precision
, -lim
);
17404 /* Padding specified. Don't let it be more than
17405 current maximum. */
17407 lim
= min (precision
, lim
);
17409 /* If that's more padding than already wanted, queue it.
17410 But don't reduce padding already specified even if
17411 that is beyond the current truncation point. */
17412 field_width
= max (lim
, field_width
);
17416 else if (STRINGP (car
) || CONSP (car
))
17418 register int limit
= 50;
17419 /* Limit is to protect against circular lists. */
17422 && (precision
<= 0 || n
< precision
))
17424 n
+= display_mode_element (it
, depth
,
17425 /* Do padding only after the last
17426 element in the list. */
17427 (! CONSP (XCDR (elt
))
17430 precision
- n
, XCAR (elt
),
17440 elt
= build_string ("*invalid*");
17444 /* Pad to FIELD_WIDTH. */
17445 if (field_width
> 0 && n
< field_width
)
17447 switch (mode_line_target
)
17449 case MODE_LINE_NOPROP
:
17450 case MODE_LINE_TITLE
:
17451 n
+= store_mode_line_noprop ("", field_width
- n
, 0);
17453 case MODE_LINE_STRING
:
17454 n
+= store_mode_line_string ("", Qnil
, 0, field_width
- n
, 0, Qnil
);
17456 case MODE_LINE_DISPLAY
:
17457 n
+= display_string ("", Qnil
, Qnil
, 0, 0, it
, field_width
- n
,
17466 /* Store a mode-line string element in mode_line_string_list.
17468 If STRING is non-null, display that C string. Otherwise, the Lisp
17469 string LISP_STRING is displayed.
17471 FIELD_WIDTH is the minimum number of output glyphs to produce.
17472 If STRING has fewer characters than FIELD_WIDTH, pad to the right
17473 with spaces. FIELD_WIDTH <= 0 means don't pad.
17475 PRECISION is the maximum number of characters to output from
17476 STRING. PRECISION <= 0 means don't truncate the string.
17478 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
17479 properties to the string.
17481 PROPS are the properties to add to the string.
17482 The mode_line_string_face face property is always added to the string.
17486 store_mode_line_string (string
, lisp_string
, copy_string
, field_width
, precision
, props
)
17488 Lisp_Object lisp_string
;
17497 if (string
!= NULL
)
17499 len
= strlen (string
);
17500 if (precision
> 0 && len
> precision
)
17502 lisp_string
= make_string (string
, len
);
17504 props
= mode_line_string_face_prop
;
17505 else if (!NILP (mode_line_string_face
))
17507 Lisp_Object face
= Fplist_get (props
, Qface
);
17508 props
= Fcopy_sequence (props
);
17510 face
= mode_line_string_face
;
17512 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
17513 props
= Fplist_put (props
, Qface
, face
);
17515 Fadd_text_properties (make_number (0), make_number (len
),
17516 props
, lisp_string
);
17520 len
= XFASTINT (Flength (lisp_string
));
17521 if (precision
> 0 && len
> precision
)
17524 lisp_string
= Fsubstring (lisp_string
, make_number (0), make_number (len
));
17527 if (!NILP (mode_line_string_face
))
17531 props
= Ftext_properties_at (make_number (0), lisp_string
);
17532 face
= Fplist_get (props
, Qface
);
17534 face
= mode_line_string_face
;
17536 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
17537 props
= Fcons (Qface
, Fcons (face
, Qnil
));
17539 lisp_string
= Fcopy_sequence (lisp_string
);
17542 Fadd_text_properties (make_number (0), make_number (len
),
17543 props
, lisp_string
);
17548 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
17552 if (field_width
> len
)
17554 field_width
-= len
;
17555 lisp_string
= Fmake_string (make_number (field_width
), make_number (' '));
17557 Fadd_text_properties (make_number (0), make_number (field_width
),
17558 props
, lisp_string
);
17559 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
17567 DEFUN ("format-mode-line", Fformat_mode_line
, Sformat_mode_line
,
17569 doc
: /* Format a string out of a mode line format specification.
17570 First arg FORMAT specifies the mode line format (see `mode-line-format'
17571 for details) to use.
17573 Optional second arg FACE specifies the face property to put
17574 on all characters for which no face is specified.
17575 The value t means whatever face the window's mode line currently uses
17576 \(either `mode-line' or `mode-line-inactive', depending).
17577 A value of nil means the default is no face property.
17578 If FACE is an integer, the value string has no text properties.
17580 Optional third and fourth args WINDOW and BUFFER specify the window
17581 and buffer to use as the context for the formatting (defaults
17582 are the selected window and the window's buffer). */)
17583 (format
, face
, window
, buffer
)
17584 Lisp_Object format
, face
, window
, buffer
;
17589 struct buffer
*old_buffer
= NULL
;
17591 int no_props
= INTEGERP (face
);
17592 int count
= SPECPDL_INDEX ();
17594 int string_start
= 0;
17597 window
= selected_window
;
17598 CHECK_WINDOW (window
);
17599 w
= XWINDOW (window
);
17602 buffer
= w
->buffer
;
17603 CHECK_BUFFER (buffer
);
17605 /* Make formatting the modeline a non-op when noninteractive, otherwise
17606 there will be problems later caused by a partially initialized frame. */
17607 if (NILP (format
) || noninteractive
)
17608 return empty_unibyte_string
;
17616 face
= (EQ (window
, selected_window
) ? Qmode_line
: Qmode_line_inactive
);
17617 face_id
= lookup_named_face (XFRAME (WINDOW_FRAME (w
)), face
, 0);
17621 face_id
= DEFAULT_FACE_ID
;
17623 if (XBUFFER (buffer
) != current_buffer
)
17624 old_buffer
= current_buffer
;
17626 /* Save things including mode_line_proptrans_alist,
17627 and set that to nil so that we don't alter the outer value. */
17628 record_unwind_protect (unwind_format_mode_line
,
17629 format_mode_line_unwind_data (old_buffer
, 1));
17630 mode_line_proptrans_alist
= Qnil
;
17633 set_buffer_internal_1 (XBUFFER (buffer
));
17635 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
17639 mode_line_target
= MODE_LINE_NOPROP
;
17640 mode_line_string_face_prop
= Qnil
;
17641 mode_line_string_list
= Qnil
;
17642 string_start
= MODE_LINE_NOPROP_LEN (0);
17646 mode_line_target
= MODE_LINE_STRING
;
17647 mode_line_string_list
= Qnil
;
17648 mode_line_string_face
= face
;
17649 mode_line_string_face_prop
17650 = (NILP (face
) ? Qnil
: Fcons (Qface
, Fcons (face
, Qnil
)));
17653 push_kboard (FRAME_KBOARD (it
.f
));
17654 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
17659 len
= MODE_LINE_NOPROP_LEN (string_start
);
17660 str
= make_string (mode_line_noprop_buf
+ string_start
, len
);
17664 mode_line_string_list
= Fnreverse (mode_line_string_list
);
17665 str
= Fmapconcat (intern ("identity"), mode_line_string_list
,
17666 empty_unibyte_string
);
17669 unbind_to (count
, Qnil
);
17673 /* Write a null-terminated, right justified decimal representation of
17674 the positive integer D to BUF using a minimal field width WIDTH. */
17677 pint2str (buf
, width
, d
)
17678 register char *buf
;
17679 register int width
;
17682 register char *p
= buf
;
17690 *p
++ = d
% 10 + '0';
17695 for (width
-= (int) (p
- buf
); width
> 0; --width
)
17706 /* Write a null-terminated, right justified decimal and "human
17707 readable" representation of the nonnegative integer D to BUF using
17708 a minimal field width WIDTH. D should be smaller than 999.5e24. */
17710 static const char power_letter
[] =
17724 pint2hrstr (buf
, width
, d
)
17729 /* We aim to represent the nonnegative integer D as
17730 QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
17733 /* -1 means: do not use TENTHS. */
17737 /* Length of QUOTIENT.TENTHS as a string. */
17743 if (1000 <= quotient
)
17745 /* Scale to the appropriate EXPONENT. */
17748 remainder
= quotient
% 1000;
17752 while (1000 <= quotient
);
17754 /* Round to nearest and decide whether to use TENTHS or not. */
17757 tenths
= remainder
/ 100;
17758 if (50 <= remainder
% 100)
17765 if (quotient
== 10)
17773 if (500 <= remainder
)
17775 if (quotient
< 999)
17786 /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
17787 if (tenths
== -1 && quotient
<= 99)
17794 p
= psuffix
= buf
+ max (width
, length
);
17796 /* Print EXPONENT. */
17798 *psuffix
++ = power_letter
[exponent
];
17801 /* Print TENTHS. */
17804 *--p
= '0' + tenths
;
17808 /* Print QUOTIENT. */
17811 int digit
= quotient
% 10;
17812 *--p
= '0' + digit
;
17814 while ((quotient
/= 10) != 0);
17816 /* Print leading spaces. */
17821 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
17822 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
17823 type of CODING_SYSTEM. Return updated pointer into BUF. */
17825 static unsigned char invalid_eol_type
[] = "(*invalid*)";
17828 decode_mode_spec_coding (coding_system
, buf
, eol_flag
)
17829 Lisp_Object coding_system
;
17830 register char *buf
;
17834 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
17835 const unsigned char *eol_str
;
17837 /* The EOL conversion we are using. */
17838 Lisp_Object eoltype
;
17840 val
= CODING_SYSTEM_SPEC (coding_system
);
17843 if (!VECTORP (val
)) /* Not yet decided. */
17848 eoltype
= eol_mnemonic_undecided
;
17849 /* Don't mention EOL conversion if it isn't decided. */
17854 Lisp_Object eolvalue
;
17856 attrs
= AREF (val
, 0);
17857 eolvalue
= AREF (val
, 2);
17860 *buf
++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs
));
17864 /* The EOL conversion that is normal on this system. */
17866 if (NILP (eolvalue
)) /* Not yet decided. */
17867 eoltype
= eol_mnemonic_undecided
;
17868 else if (VECTORP (eolvalue
)) /* Not yet decided. */
17869 eoltype
= eol_mnemonic_undecided
;
17870 else /* eolvalue is Qunix, Qdos, or Qmac. */
17871 eoltype
= (EQ (eolvalue
, Qunix
)
17872 ? eol_mnemonic_unix
17873 : (EQ (eolvalue
, Qdos
) == 1
17874 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
17880 /* Mention the EOL conversion if it is not the usual one. */
17881 if (STRINGP (eoltype
))
17883 eol_str
= SDATA (eoltype
);
17884 eol_str_len
= SBYTES (eoltype
);
17886 else if (CHARACTERP (eoltype
))
17888 unsigned char *tmp
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
);
17889 eol_str_len
= CHAR_STRING (XINT (eoltype
), tmp
);
17894 eol_str
= invalid_eol_type
;
17895 eol_str_len
= sizeof (invalid_eol_type
) - 1;
17897 bcopy (eol_str
, buf
, eol_str_len
);
17898 buf
+= eol_str_len
;
17904 /* Return a string for the output of a mode line %-spec for window W,
17905 generated by character C. PRECISION >= 0 means don't return a
17906 string longer than that value. FIELD_WIDTH > 0 means pad the
17907 string returned with spaces to that value. Return 1 in *MULTIBYTE
17908 if the result is multibyte text.
17910 Note we operate on the current buffer for most purposes,
17911 the exception being w->base_line_pos. */
17913 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
17916 decode_mode_spec (w
, c
, field_width
, precision
, multibyte
)
17919 int field_width
, precision
;
17923 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
17924 char *decode_mode_spec_buf
= f
->decode_mode_spec_buffer
;
17925 struct buffer
*b
= current_buffer
;
17933 if (!NILP (b
->read_only
))
17935 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
17940 /* This differs from %* only for a modified read-only buffer. */
17941 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
17943 if (!NILP (b
->read_only
))
17948 /* This differs from %* in ignoring read-only-ness. */
17949 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
17961 if (command_loop_level
> 5)
17963 p
= decode_mode_spec_buf
;
17964 for (i
= 0; i
< command_loop_level
; i
++)
17967 return decode_mode_spec_buf
;
17975 if (command_loop_level
> 5)
17977 p
= decode_mode_spec_buf
;
17978 for (i
= 0; i
< command_loop_level
; i
++)
17981 return decode_mode_spec_buf
;
17988 /* Let lots_of_dashes be a string of infinite length. */
17989 if (mode_line_target
== MODE_LINE_NOPROP
||
17990 mode_line_target
== MODE_LINE_STRING
)
17992 if (field_width
<= 0
17993 || field_width
> sizeof (lots_of_dashes
))
17995 for (i
= 0; i
< FRAME_MESSAGE_BUF_SIZE (f
) - 1; ++i
)
17996 decode_mode_spec_buf
[i
] = '-';
17997 decode_mode_spec_buf
[i
] = '\0';
17998 return decode_mode_spec_buf
;
18001 return lots_of_dashes
;
18009 /* %c and %l are ignored in `frame-title-format'.
18010 (In redisplay_internal, the frame title is drawn _before_ the
18011 windows are updated, so the stuff which depends on actual
18012 window contents (such as %l) may fail to render properly, or
18013 even crash emacs.) */
18014 if (mode_line_target
== MODE_LINE_TITLE
)
18018 int col
= (int) current_column (); /* iftc */
18019 w
->column_number_displayed
= make_number (col
);
18020 pint2str (decode_mode_spec_buf
, field_width
, col
);
18021 return decode_mode_spec_buf
;
18025 #ifndef SYSTEM_MALLOC
18027 if (NILP (Vmemory_full
))
18030 return "!MEM FULL! ";
18037 /* %F displays the frame name. */
18038 if (!NILP (f
->title
))
18039 return (char *) SDATA (f
->title
);
18040 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
18041 return (char *) SDATA (f
->name
);
18050 int size
= ZV
- BEGV
;
18051 pint2str (decode_mode_spec_buf
, field_width
, size
);
18052 return decode_mode_spec_buf
;
18057 int size
= ZV
- BEGV
;
18058 pint2hrstr (decode_mode_spec_buf
, field_width
, size
);
18059 return decode_mode_spec_buf
;
18064 int startpos
, startpos_byte
, line
, linepos
, linepos_byte
;
18065 int topline
, nlines
, junk
, height
;
18067 /* %c and %l are ignored in `frame-title-format'. */
18068 if (mode_line_target
== MODE_LINE_TITLE
)
18071 startpos
= XMARKER (w
->start
)->charpos
;
18072 startpos_byte
= marker_byte_position (w
->start
);
18073 height
= WINDOW_TOTAL_LINES (w
);
18075 /* If we decided that this buffer isn't suitable for line numbers,
18076 don't forget that too fast. */
18077 if (EQ (w
->base_line_pos
, w
->buffer
))
18079 /* But do forget it, if the window shows a different buffer now. */
18080 else if (BUFFERP (w
->base_line_pos
))
18081 w
->base_line_pos
= Qnil
;
18083 /* If the buffer is very big, don't waste time. */
18084 if (INTEGERP (Vline_number_display_limit
)
18085 && BUF_ZV (b
) - BUF_BEGV (b
) > XINT (Vline_number_display_limit
))
18087 w
->base_line_pos
= Qnil
;
18088 w
->base_line_number
= Qnil
;
18092 if (!NILP (w
->base_line_number
)
18093 && !NILP (w
->base_line_pos
)
18094 && XFASTINT (w
->base_line_pos
) <= startpos
)
18096 line
= XFASTINT (w
->base_line_number
);
18097 linepos
= XFASTINT (w
->base_line_pos
);
18098 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
18103 linepos
= BUF_BEGV (b
);
18104 linepos_byte
= BUF_BEGV_BYTE (b
);
18107 /* Count lines from base line to window start position. */
18108 nlines
= display_count_lines (linepos
, linepos_byte
,
18112 topline
= nlines
+ line
;
18114 /* Determine a new base line, if the old one is too close
18115 or too far away, or if we did not have one.
18116 "Too close" means it's plausible a scroll-down would
18117 go back past it. */
18118 if (startpos
== BUF_BEGV (b
))
18120 w
->base_line_number
= make_number (topline
);
18121 w
->base_line_pos
= make_number (BUF_BEGV (b
));
18123 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
18124 || linepos
== BUF_BEGV (b
))
18126 int limit
= BUF_BEGV (b
);
18127 int limit_byte
= BUF_BEGV_BYTE (b
);
18129 int distance
= (height
* 2 + 30) * line_number_display_limit_width
;
18131 if (startpos
- distance
> limit
)
18133 limit
= startpos
- distance
;
18134 limit_byte
= CHAR_TO_BYTE (limit
);
18137 nlines
= display_count_lines (startpos
, startpos_byte
,
18139 - (height
* 2 + 30),
18141 /* If we couldn't find the lines we wanted within
18142 line_number_display_limit_width chars per line,
18143 give up on line numbers for this window. */
18144 if (position
== limit_byte
&& limit
== startpos
- distance
)
18146 w
->base_line_pos
= w
->buffer
;
18147 w
->base_line_number
= Qnil
;
18151 w
->base_line_number
= make_number (topline
- nlines
);
18152 w
->base_line_pos
= make_number (BYTE_TO_CHAR (position
));
18155 /* Now count lines from the start pos to point. */
18156 nlines
= display_count_lines (startpos
, startpos_byte
,
18157 PT_BYTE
, PT
, &junk
);
18159 /* Record that we did display the line number. */
18160 line_number_displayed
= 1;
18162 /* Make the string to show. */
18163 pint2str (decode_mode_spec_buf
, field_width
, topline
+ nlines
);
18164 return decode_mode_spec_buf
;
18167 char* p
= decode_mode_spec_buf
;
18168 int pad
= field_width
- 2;
18174 return decode_mode_spec_buf
;
18180 obj
= b
->mode_name
;
18184 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
18190 int pos
= marker_position (w
->start
);
18191 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
18193 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
18195 if (pos
<= BUF_BEGV (b
))
18200 else if (pos
<= BUF_BEGV (b
))
18204 if (total
> 1000000)
18205 /* Do it differently for a large value, to avoid overflow. */
18206 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
18208 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
18209 /* We can't normally display a 3-digit number,
18210 so get us a 2-digit number that is close. */
18213 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
18214 return decode_mode_spec_buf
;
18218 /* Display percentage of size above the bottom of the screen. */
18221 int toppos
= marker_position (w
->start
);
18222 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
18223 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
18225 if (botpos
>= BUF_ZV (b
))
18227 if (toppos
<= BUF_BEGV (b
))
18234 if (total
> 1000000)
18235 /* Do it differently for a large value, to avoid overflow. */
18236 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
18238 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
18239 /* We can't normally display a 3-digit number,
18240 so get us a 2-digit number that is close. */
18243 if (toppos
<= BUF_BEGV (b
))
18244 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
18246 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
18247 return decode_mode_spec_buf
;
18252 /* status of process */
18253 obj
= Fget_buffer_process (Fcurrent_buffer ());
18255 return "no process";
18256 #ifdef subprocesses
18257 obj
= Fsymbol_name (Fprocess_status (obj
));
18264 val
= call1 (intern ("file-remote-p"), current_buffer
->directory
);
18271 case 't': /* indicate TEXT or BINARY */
18272 #ifdef MODE_LINE_BINARY_TEXT
18273 return MODE_LINE_BINARY_TEXT (b
);
18279 /* coding-system (not including end-of-line format) */
18281 /* coding-system (including end-of-line type) */
18283 int eol_flag
= (c
== 'Z');
18284 char *p
= decode_mode_spec_buf
;
18286 if (! FRAME_WINDOW_P (f
))
18288 /* No need to mention EOL here--the terminal never needs
18289 to do EOL conversion. */
18290 p
= decode_mode_spec_coding (CODING_ID_NAME
18291 (FRAME_KEYBOARD_CODING (f
)->id
),
18293 p
= decode_mode_spec_coding (CODING_ID_NAME
18294 (FRAME_TERMINAL_CODING (f
)->id
),
18297 p
= decode_mode_spec_coding (b
->buffer_file_coding_system
,
18300 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
18301 #ifdef subprocesses
18302 obj
= Fget_buffer_process (Fcurrent_buffer ());
18303 if (PROCESSP (obj
))
18305 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
18307 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
18310 #endif /* subprocesses */
18313 return decode_mode_spec_buf
;
18319 *multibyte
= STRING_MULTIBYTE (obj
);
18320 return (char *) SDATA (obj
);
18327 /* Count up to COUNT lines starting from START / START_BYTE.
18328 But don't go beyond LIMIT_BYTE.
18329 Return the number of lines thus found (always nonnegative).
18331 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
18334 display_count_lines (start
, start_byte
, limit_byte
, count
, byte_pos_ptr
)
18335 int start
, start_byte
, limit_byte
, count
;
18338 register unsigned char *cursor
;
18339 unsigned char *base
;
18341 register int ceiling
;
18342 register unsigned char *ceiling_addr
;
18343 int orig_count
= count
;
18345 /* If we are not in selective display mode,
18346 check only for newlines. */
18347 int selective_display
= (!NILP (current_buffer
->selective_display
)
18348 && !INTEGERP (current_buffer
->selective_display
));
18352 while (start_byte
< limit_byte
)
18354 ceiling
= BUFFER_CEILING_OF (start_byte
);
18355 ceiling
= min (limit_byte
- 1, ceiling
);
18356 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
18357 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
18360 if (selective_display
)
18361 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
18364 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
18367 if (cursor
!= ceiling_addr
)
18371 start_byte
+= cursor
- base
+ 1;
18372 *byte_pos_ptr
= start_byte
;
18376 if (++cursor
== ceiling_addr
)
18382 start_byte
+= cursor
- base
;
18387 while (start_byte
> limit_byte
)
18389 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
18390 ceiling
= max (limit_byte
, ceiling
);
18391 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
18392 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
18395 if (selective_display
)
18396 while (--cursor
!= ceiling_addr
18397 && *cursor
!= '\n' && *cursor
!= 015)
18400 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
18403 if (cursor
!= ceiling_addr
)
18407 start_byte
+= cursor
- base
+ 1;
18408 *byte_pos_ptr
= start_byte
;
18409 /* When scanning backwards, we should
18410 not count the newline posterior to which we stop. */
18411 return - orig_count
- 1;
18417 /* Here we add 1 to compensate for the last decrement
18418 of CURSOR, which took it past the valid range. */
18419 start_byte
+= cursor
- base
+ 1;
18423 *byte_pos_ptr
= limit_byte
;
18426 return - orig_count
+ count
;
18427 return orig_count
- count
;
18433 /***********************************************************************
18435 ***********************************************************************/
18437 /* Display a NUL-terminated string, starting with index START.
18439 If STRING is non-null, display that C string. Otherwise, the Lisp
18440 string LISP_STRING is displayed.
18442 If FACE_STRING is not nil, FACE_STRING_POS is a position in
18443 FACE_STRING. Display STRING or LISP_STRING with the face at
18444 FACE_STRING_POS in FACE_STRING:
18446 Display the string in the environment given by IT, but use the
18447 standard display table, temporarily.
18449 FIELD_WIDTH is the minimum number of output glyphs to produce.
18450 If STRING has fewer characters than FIELD_WIDTH, pad to the right
18451 with spaces. If STRING has more characters, more than FIELD_WIDTH
18452 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
18454 PRECISION is the maximum number of characters to output from
18455 STRING. PRECISION < 0 means don't truncate the string.
18457 This is roughly equivalent to printf format specifiers:
18459 FIELD_WIDTH PRECISION PRINTF
18460 ----------------------------------------
18466 MULTIBYTE zero means do not display multibyte chars, > 0 means do
18467 display them, and < 0 means obey the current buffer's value of
18468 enable_multibyte_characters.
18470 Value is the number of columns displayed. */
18473 display_string (string
, lisp_string
, face_string
, face_string_pos
,
18474 start
, it
, field_width
, precision
, max_x
, multibyte
)
18475 unsigned char *string
;
18476 Lisp_Object lisp_string
;
18477 Lisp_Object face_string
;
18478 int face_string_pos
;
18481 int field_width
, precision
, max_x
;
18484 int hpos_at_start
= it
->hpos
;
18485 int saved_face_id
= it
->face_id
;
18486 struct glyph_row
*row
= it
->glyph_row
;
18488 /* Initialize the iterator IT for iteration over STRING beginning
18489 with index START. */
18490 reseat_to_string (it
, string
, lisp_string
, start
,
18491 precision
, field_width
, multibyte
);
18493 /* If displaying STRING, set up the face of the iterator
18494 from LISP_STRING, if that's given. */
18495 if (STRINGP (face_string
))
18501 = face_at_string_position (it
->w
, face_string
, face_string_pos
,
18502 0, it
->region_beg_charpos
,
18503 it
->region_end_charpos
,
18504 &endptr
, it
->base_face_id
, 0);
18505 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
18506 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
18509 /* Set max_x to the maximum allowed X position. Don't let it go
18510 beyond the right edge of the window. */
18512 max_x
= it
->last_visible_x
;
18514 max_x
= min (max_x
, it
->last_visible_x
);
18516 /* Skip over display elements that are not visible. because IT->w is
18518 if (it
->current_x
< it
->first_visible_x
)
18519 move_it_in_display_line_to (it
, 100000, it
->first_visible_x
,
18520 MOVE_TO_POS
| MOVE_TO_X
);
18522 row
->ascent
= it
->max_ascent
;
18523 row
->height
= it
->max_ascent
+ it
->max_descent
;
18524 row
->phys_ascent
= it
->max_phys_ascent
;
18525 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
18526 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
18528 /* This condition is for the case that we are called with current_x
18529 past last_visible_x. */
18530 while (it
->current_x
< max_x
)
18532 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
18534 /* Get the next display element. */
18535 if (!get_next_display_element (it
))
18538 /* Produce glyphs. */
18539 x_before
= it
->current_x
;
18540 n_glyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
18541 PRODUCE_GLYPHS (it
);
18543 nglyphs
= it
->glyph_row
->used
[TEXT_AREA
] - n_glyphs_before
;
18546 while (i
< nglyphs
)
18548 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
18550 if (!it
->truncate_lines_p
18551 && x
+ glyph
->pixel_width
> max_x
)
18553 /* End of continued line or max_x reached. */
18554 if (CHAR_GLYPH_PADDING_P (*glyph
))
18556 /* A wide character is unbreakable. */
18557 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
18558 it
->current_x
= x_before
;
18562 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
18567 else if (x
+ glyph
->pixel_width
>= it
->first_visible_x
)
18569 /* Glyph is at least partially visible. */
18571 if (x
< it
->first_visible_x
)
18572 it
->glyph_row
->x
= x
- it
->first_visible_x
;
18576 /* Glyph is off the left margin of the display area.
18577 Should not happen. */
18581 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
18582 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
18583 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
18584 row
->phys_height
= max (row
->phys_height
,
18585 it
->max_phys_ascent
+ it
->max_phys_descent
);
18586 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
18587 it
->max_extra_line_spacing
);
18588 x
+= glyph
->pixel_width
;
18592 /* Stop if max_x reached. */
18596 /* Stop at line ends. */
18597 if (ITERATOR_AT_END_OF_LINE_P (it
))
18599 it
->continuation_lines_width
= 0;
18603 set_iterator_to_next (it
, 1);
18605 /* Stop if truncating at the right edge. */
18606 if (it
->truncate_lines_p
18607 && it
->current_x
>= it
->last_visible_x
)
18609 /* Add truncation mark, but don't do it if the line is
18610 truncated at a padding space. */
18611 if (IT_CHARPOS (*it
) < it
->string_nchars
)
18613 if (!FRAME_WINDOW_P (it
->f
))
18617 if (it
->current_x
> it
->last_visible_x
)
18619 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
18620 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
18622 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
18624 row
->used
[TEXT_AREA
] = i
;
18625 produce_special_glyphs (it
, IT_TRUNCATION
);
18628 produce_special_glyphs (it
, IT_TRUNCATION
);
18630 it
->glyph_row
->truncated_on_right_p
= 1;
18636 /* Maybe insert a truncation at the left. */
18637 if (it
->first_visible_x
18638 && IT_CHARPOS (*it
) > 0)
18640 if (!FRAME_WINDOW_P (it
->f
))
18641 insert_left_trunc_glyphs (it
);
18642 it
->glyph_row
->truncated_on_left_p
= 1;
18645 it
->face_id
= saved_face_id
;
18647 /* Value is number of columns displayed. */
18648 return it
->hpos
- hpos_at_start
;
18653 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
18654 appears as an element of LIST or as the car of an element of LIST.
18655 If PROPVAL is a list, compare each element against LIST in that
18656 way, and return 1/2 if any element of PROPVAL is found in LIST.
18657 Otherwise return 0. This function cannot quit.
18658 The return value is 2 if the text is invisible but with an ellipsis
18659 and 1 if it's invisible and without an ellipsis. */
18662 invisible_p (propval
, list
)
18663 register Lisp_Object propval
;
18666 register Lisp_Object tail
, proptail
;
18668 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
18670 register Lisp_Object tem
;
18672 if (EQ (propval
, tem
))
18674 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
18675 return NILP (XCDR (tem
)) ? 1 : 2;
18678 if (CONSP (propval
))
18680 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
18682 Lisp_Object propelt
;
18683 propelt
= XCAR (proptail
);
18684 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
18686 register Lisp_Object tem
;
18688 if (EQ (propelt
, tem
))
18690 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
18691 return NILP (XCDR (tem
)) ? 1 : 2;
18699 DEFUN ("invisible-p", Finvisible_p
, Sinvisible_p
, 1, 1, 0,
18700 doc
: /* Non-nil if the property makes the text invisible.
18701 POS-OR-PROP can be a marker or number, in which case it is taken to be
18702 a position in the current buffer and the value of the `invisible' property
18703 is checked; or it can be some other value, which is then presumed to be the
18704 value of the `invisible' property of the text of interest.
18705 The non-nil value returned can be t for truly invisible text or something
18706 else if the text is replaced by an ellipsis. */)
18708 Lisp_Object pos_or_prop
;
18711 = (NATNUMP (pos_or_prop
) || MARKERP (pos_or_prop
)
18712 ? Fget_char_property (pos_or_prop
, Qinvisible
, Qnil
)
18714 int invis
= TEXT_PROP_MEANS_INVISIBLE (prop
);
18715 return (invis
== 0 ? Qnil
18717 : make_number (invis
));
18720 /* Calculate a width or height in pixels from a specification using
18721 the following elements:
18724 NUM - a (fractional) multiple of the default font width/height
18725 (NUM) - specifies exactly NUM pixels
18726 UNIT - a fixed number of pixels, see below.
18727 ELEMENT - size of a display element in pixels, see below.
18728 (NUM . SPEC) - equals NUM * SPEC
18729 (+ SPEC SPEC ...) - add pixel values
18730 (- SPEC SPEC ...) - subtract pixel values
18731 (- SPEC) - negate pixel value
18734 INT or FLOAT - a number constant
18735 SYMBOL - use symbol's (buffer local) variable binding.
18738 in - pixels per inch *)
18739 mm - pixels per 1/1000 meter *)
18740 cm - pixels per 1/100 meter *)
18741 width - width of current font in pixels.
18742 height - height of current font in pixels.
18744 *) using the ratio(s) defined in display-pixels-per-inch.
18748 left-fringe - left fringe width in pixels
18749 right-fringe - right fringe width in pixels
18751 left-margin - left margin width in pixels
18752 right-margin - right margin width in pixels
18754 scroll-bar - scroll-bar area width in pixels
18758 Pixels corresponding to 5 inches:
18761 Total width of non-text areas on left side of window (if scroll-bar is on left):
18762 '(space :width (+ left-fringe left-margin scroll-bar))
18764 Align to first text column (in header line):
18765 '(space :align-to 0)
18767 Align to middle of text area minus half the width of variable `my-image'
18768 containing a loaded image:
18769 '(space :align-to (0.5 . (- text my-image)))
18771 Width of left margin minus width of 1 character in the default font:
18772 '(space :width (- left-margin 1))
18774 Width of left margin minus width of 2 characters in the current font:
18775 '(space :width (- left-margin (2 . width)))
18777 Center 1 character over left-margin (in header line):
18778 '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
18780 Different ways to express width of left fringe plus left margin minus one pixel:
18781 '(space :width (- (+ left-fringe left-margin) (1)))
18782 '(space :width (+ left-fringe left-margin (- (1))))
18783 '(space :width (+ left-fringe left-margin (-1)))
18787 #define NUMVAL(X) \
18788 ((INTEGERP (X) || FLOATP (X)) \
18793 calc_pixel_width_or_height (res
, it
, prop
, font
, width_p
, align_to
)
18798 int width_p
, *align_to
;
18802 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
18803 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
18806 return OK_PIXELS (0);
18808 xassert (FRAME_LIVE_P (it
->f
));
18810 if (SYMBOLP (prop
))
18812 if (SCHARS (SYMBOL_NAME (prop
)) == 2)
18814 char *unit
= SDATA (SYMBOL_NAME (prop
));
18816 if (unit
[0] == 'i' && unit
[1] == 'n')
18818 else if (unit
[0] == 'm' && unit
[1] == 'm')
18820 else if (unit
[0] == 'c' && unit
[1] == 'm')
18827 #ifdef HAVE_WINDOW_SYSTEM
18828 if (FRAME_WINDOW_P (it
->f
)
18830 ? FRAME_X_DISPLAY_INFO (it
->f
)->resx
18831 : FRAME_X_DISPLAY_INFO (it
->f
)->resy
),
18833 return OK_PIXELS (ppi
/ pixels
);
18836 if ((ppi
= NUMVAL (Vdisplay_pixels_per_inch
), ppi
> 0)
18837 || (CONSP (Vdisplay_pixels_per_inch
)
18839 ? NUMVAL (XCAR (Vdisplay_pixels_per_inch
))
18840 : NUMVAL (XCDR (Vdisplay_pixels_per_inch
))),
18842 return OK_PIXELS (ppi
/ pixels
);
18848 #ifdef HAVE_WINDOW_SYSTEM
18849 if (EQ (prop
, Qheight
))
18850 return OK_PIXELS (font
? FONT_HEIGHT ((XFontStruct
*)font
) : FRAME_LINE_HEIGHT (it
->f
));
18851 if (EQ (prop
, Qwidth
))
18852 return OK_PIXELS (font
? FONT_WIDTH ((XFontStruct
*)font
) : FRAME_COLUMN_WIDTH (it
->f
));
18854 if (EQ (prop
, Qheight
) || EQ (prop
, Qwidth
))
18855 return OK_PIXELS (1);
18858 if (EQ (prop
, Qtext
))
18859 return OK_PIXELS (width_p
18860 ? window_box_width (it
->w
, TEXT_AREA
)
18861 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
));
18863 if (align_to
&& *align_to
< 0)
18866 if (EQ (prop
, Qleft
))
18867 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
));
18868 if (EQ (prop
, Qright
))
18869 return OK_ALIGN_TO (window_box_right_offset (it
->w
, TEXT_AREA
));
18870 if (EQ (prop
, Qcenter
))
18871 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
)
18872 + window_box_width (it
->w
, TEXT_AREA
) / 2);
18873 if (EQ (prop
, Qleft_fringe
))
18874 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
18875 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it
->w
)
18876 : window_box_right_offset (it
->w
, LEFT_MARGIN_AREA
));
18877 if (EQ (prop
, Qright_fringe
))
18878 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
18879 ? window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
18880 : window_box_right_offset (it
->w
, TEXT_AREA
));
18881 if (EQ (prop
, Qleft_margin
))
18882 return OK_ALIGN_TO (window_box_left_offset (it
->w
, LEFT_MARGIN_AREA
));
18883 if (EQ (prop
, Qright_margin
))
18884 return OK_ALIGN_TO (window_box_left_offset (it
->w
, RIGHT_MARGIN_AREA
));
18885 if (EQ (prop
, Qscroll_bar
))
18886 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it
->w
)
18888 : (window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
18889 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
18890 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
18895 if (EQ (prop
, Qleft_fringe
))
18896 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it
->w
));
18897 if (EQ (prop
, Qright_fringe
))
18898 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
));
18899 if (EQ (prop
, Qleft_margin
))
18900 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it
->w
));
18901 if (EQ (prop
, Qright_margin
))
18902 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it
->w
));
18903 if (EQ (prop
, Qscroll_bar
))
18904 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it
->w
));
18907 prop
= Fbuffer_local_value (prop
, it
->w
->buffer
);
18910 if (INTEGERP (prop
) || FLOATP (prop
))
18912 int base_unit
= (width_p
18913 ? FRAME_COLUMN_WIDTH (it
->f
)
18914 : FRAME_LINE_HEIGHT (it
->f
));
18915 return OK_PIXELS (XFLOATINT (prop
) * base_unit
);
18920 Lisp_Object car
= XCAR (prop
);
18921 Lisp_Object cdr
= XCDR (prop
);
18925 #ifdef HAVE_WINDOW_SYSTEM
18926 if (FRAME_WINDOW_P (it
->f
)
18927 && valid_image_p (prop
))
18929 int id
= lookup_image (it
->f
, prop
);
18930 struct image
*img
= IMAGE_FROM_ID (it
->f
, id
);
18932 return OK_PIXELS (width_p
? img
->width
: img
->height
);
18935 if (EQ (car
, Qplus
) || EQ (car
, Qminus
))
18941 while (CONSP (cdr
))
18943 if (!calc_pixel_width_or_height (&px
, it
, XCAR (cdr
),
18944 font
, width_p
, align_to
))
18947 pixels
= (EQ (car
, Qplus
) ? px
: -px
), first
= 0;
18952 if (EQ (car
, Qminus
))
18954 return OK_PIXELS (pixels
);
18957 car
= Fbuffer_local_value (car
, it
->w
->buffer
);
18960 if (INTEGERP (car
) || FLOATP (car
))
18963 pixels
= XFLOATINT (car
);
18965 return OK_PIXELS (pixels
);
18966 if (calc_pixel_width_or_height (&fact
, it
, cdr
,
18967 font
, width_p
, align_to
))
18968 return OK_PIXELS (pixels
* fact
);
18979 /***********************************************************************
18981 ***********************************************************************/
18983 #ifdef HAVE_WINDOW_SYSTEM
18988 dump_glyph_string (s
)
18989 struct glyph_string
*s
;
18991 fprintf (stderr
, "glyph string\n");
18992 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
18993 s
->x
, s
->y
, s
->width
, s
->height
);
18994 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
18995 fprintf (stderr
, " hl = %d\n", s
->hl
);
18996 fprintf (stderr
, " left overhang = %d, right = %d\n",
18997 s
->left_overhang
, s
->right_overhang
);
18998 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
18999 fprintf (stderr
, " extends to end of line = %d\n",
19000 s
->extends_to_end_of_line_p
);
19001 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
19002 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
19005 #endif /* GLYPH_DEBUG */
19007 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
19008 of XChar2b structures for S; it can't be allocated in
19009 init_glyph_string because it must be allocated via `alloca'. W
19010 is the window on which S is drawn. ROW and AREA are the glyph row
19011 and area within the row from which S is constructed. START is the
19012 index of the first glyph structure covered by S. HL is a
19013 face-override for drawing S. */
19016 #define OPTIONAL_HDC(hdc) hdc,
19017 #define DECLARE_HDC(hdc) HDC hdc;
19018 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
19019 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
19022 #ifndef OPTIONAL_HDC
19023 #define OPTIONAL_HDC(hdc)
19024 #define DECLARE_HDC(hdc)
19025 #define ALLOCATE_HDC(hdc, f)
19026 #define RELEASE_HDC(hdc, f)
19030 init_glyph_string (s
, OPTIONAL_HDC (hdc
) char2b
, w
, row
, area
, start
, hl
)
19031 struct glyph_string
*s
;
19035 struct glyph_row
*row
;
19036 enum glyph_row_area area
;
19038 enum draw_glyphs_face hl
;
19040 bzero (s
, sizeof *s
);
19042 s
->f
= XFRAME (w
->frame
);
19046 s
->display
= FRAME_X_DISPLAY (s
->f
);
19047 s
->window
= FRAME_X_WINDOW (s
->f
);
19048 s
->char2b
= char2b
;
19052 s
->first_glyph
= row
->glyphs
[area
] + start
;
19053 s
->height
= row
->height
;
19054 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
19056 /* Display the internal border below the tool-bar window. */
19057 if (WINDOWP (s
->f
->tool_bar_window
)
19058 && s
->w
== XWINDOW (s
->f
->tool_bar_window
))
19059 s
->y
-= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
19061 s
->ybase
= s
->y
+ row
->ascent
;
19065 /* Append the list of glyph strings with head H and tail T to the list
19066 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
19069 append_glyph_string_lists (head
, tail
, h
, t
)
19070 struct glyph_string
**head
, **tail
;
19071 struct glyph_string
*h
, *t
;
19085 /* Prepend the list of glyph strings with head H and tail T to the
19086 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
19090 prepend_glyph_string_lists (head
, tail
, h
, t
)
19091 struct glyph_string
**head
, **tail
;
19092 struct glyph_string
*h
, *t
;
19106 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
19107 Set *HEAD and *TAIL to the resulting list. */
19110 append_glyph_string (head
, tail
, s
)
19111 struct glyph_string
**head
, **tail
;
19112 struct glyph_string
*s
;
19114 s
->next
= s
->prev
= NULL
;
19115 append_glyph_string_lists (head
, tail
, s
, s
);
19119 /* Get face and two-byte form of character C in face FACE_ID on frame
19120 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
19121 means we want to display multibyte text. DISPLAY_P non-zero means
19122 make sure that X resources for the face returned are allocated.
19123 Value is a pointer to a realized face that is ready for display if
19124 DISPLAY_P is non-zero. */
19126 static INLINE
struct face
*
19127 get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
, display_p
)
19131 int multibyte_p
, display_p
;
19133 struct face
*face
= FACE_FROM_ID (f
, face_id
);
19135 #ifdef USE_FONT_BACKEND
19136 if (enable_font_backend
)
19138 struct font
*font
= (struct font
*) face
->font_info
;
19142 unsigned code
= font
->driver
->encode_char (font
, c
);
19144 if (code
!= FONT_INVALID_CODE
)
19145 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
19147 STORE_XCHAR2B (char2b
, 0, 0);
19151 #endif /* USE_FONT_BACKEND */
19154 /* Unibyte case. We don't have to encode, but we have to make
19155 sure to use a face suitable for unibyte. */
19156 STORE_XCHAR2B (char2b
, 0, c
);
19157 face_id
= FACE_FOR_CHAR (f
, face
, c
, -1, Qnil
);
19158 face
= FACE_FROM_ID (f
, face_id
);
19162 /* Case of ASCII in a face known to fit ASCII. */
19163 STORE_XCHAR2B (char2b
, 0, c
);
19165 else if (face
->font
!= NULL
)
19167 struct font_info
*font_info
19168 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
19169 struct charset
*charset
= CHARSET_FROM_ID (font_info
->charset
);
19170 unsigned code
= ENCODE_CHAR (charset
, c
);
19172 if (CHARSET_DIMENSION (charset
) == 1)
19173 STORE_XCHAR2B (char2b
, 0, code
);
19175 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
19176 /* Maybe encode the character in *CHAR2B. */
19177 FRAME_RIF (f
)->encode_char (c
, char2b
, font_info
, charset
, NULL
);
19180 /* Make sure X resources of the face are allocated. */
19181 #ifdef HAVE_X_WINDOWS
19185 xassert (face
!= NULL
);
19186 PREPARE_FACE_FOR_DISPLAY (f
, face
);
19193 /* Get face and two-byte form of character glyph GLYPH on frame F.
19194 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
19195 a pointer to a realized face that is ready for display. */
19197 static INLINE
struct face
*
19198 get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
19200 struct glyph
*glyph
;
19206 xassert (glyph
->type
== CHAR_GLYPH
);
19207 face
= FACE_FROM_ID (f
, glyph
->face_id
);
19212 #ifdef USE_FONT_BACKEND
19213 if (enable_font_backend
)
19215 struct font
*font
= (struct font
*) face
->font_info
;
19219 unsigned code
= font
->driver
->encode_char (font
, glyph
->u
.ch
);
19221 if (code
!= FONT_INVALID_CODE
)
19222 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
19224 STORE_XCHAR2B (char2b
, 0, code
);
19228 #endif /* USE_FONT_BACKEND */
19229 if (!glyph
->multibyte_p
)
19231 /* Unibyte case. We don't have to encode, but we have to make
19232 sure to use a face suitable for unibyte. */
19233 STORE_XCHAR2B (char2b
, 0, glyph
->u
.ch
);
19235 else if (glyph
->u
.ch
< 128)
19237 /* Case of ASCII in a face known to fit ASCII. */
19238 STORE_XCHAR2B (char2b
, 0, glyph
->u
.ch
);
19242 struct font_info
*font_info
19243 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
19246 struct charset
*charset
= CHARSET_FROM_ID (font_info
->charset
);
19247 unsigned code
= ENCODE_CHAR (charset
, glyph
->u
.ch
);
19249 if (CHARSET_DIMENSION (charset
) == 1)
19250 STORE_XCHAR2B (char2b
, 0, code
);
19252 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
19254 /* Maybe encode the character in *CHAR2B. */
19255 if (CHARSET_ID (charset
) != charset_ascii
)
19258 = FRAME_RIF (f
)->encode_char (glyph
->u
.ch
, char2b
, font_info
,
19259 charset
, two_byte_p
);
19264 /* Make sure X resources of the face are allocated. */
19265 xassert (face
!= NULL
);
19266 PREPARE_FACE_FOR_DISPLAY (f
, face
);
19271 /* Fill glyph string S with composition components specified by S->cmp.
19273 BASE_FACE is the base face of the composition.
19274 S->gidx is the index of the first component for S.
19276 OVERLAPS non-zero means S should draw the foreground only, and use
19277 its physical height for clipping. See also draw_glyphs.
19279 Value is the index of a component not in S. */
19282 fill_composite_glyph_string (s
, base_face
, overlaps
)
19283 struct glyph_string
*s
;
19284 struct face
*base_face
;
19291 s
->for_overlaps
= overlaps
;
19293 #ifdef USE_FONT_BACKEND
19294 if (enable_font_backend
&& s
->cmp
->method
== COMPOSITION_WITH_GLYPH_STRING
)
19296 Lisp_Object gstring
19297 = AREF (XHASH_TABLE (composition_hash_table
)->key_and_value
,
19298 s
->cmp
->hash_index
* 2);
19300 s
->face
= base_face
;
19301 s
->font_info
= s
->cmp
->font
;
19302 s
->font
= s
->font_info
->font
;
19303 for (i
= 0, s
->nchars
= 0; i
< s
->cmp
->glyph_len
; i
++, s
->nchars
++)
19305 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
19307 XChar2b
* store_pos
;
19308 if (NILP (LGLYPH_FROM (g
)))
19310 code
= XUINT (LGLYPH_CODE (g
));
19311 store_pos
= s
->char2b
+ i
;
19312 STORE_XCHAR2B (store_pos
, code
>> 8, code
& 0xFF);
19314 s
->width
= s
->cmp
->pixel_width
;
19317 #endif /* USE_FONT_BACKEND */
19319 /* For all glyphs of this composition, starting at the offset
19320 S->gidx, until we reach the end of the definition or encounter a
19321 glyph that requires the different face, add it to S. */
19326 s
->font_info
= NULL
;
19327 for (i
= s
->gidx
; i
< s
->cmp
->glyph_len
; i
++)
19329 int c
= COMPOSITION_GLYPH (s
->cmp
, i
);
19333 int face_id
= FACE_FOR_CHAR (s
->f
, base_face
, c
, -1, Qnil
);
19335 face
= get_char_face_and_encoding (s
->f
, c
, face_id
,
19336 s
->char2b
+ i
, 1, 1);
19342 s
->font
= s
->face
->font
;
19343 s
->font_info
= FONT_INFO_FROM_FACE (s
->f
, s
->face
);
19345 else if (s
->face
!= face
)
19352 /* All glyph strings for the same composition has the same width,
19353 i.e. the width set for the first component of the composition. */
19354 s
->width
= s
->first_glyph
->pixel_width
;
19357 /* If the specified font could not be loaded, use the frame's
19358 default font, but record the fact that we couldn't load it in
19359 the glyph string so that we can draw rectangles for the
19360 characters of the glyph string. */
19361 if (s
->font
== NULL
)
19363 s
->font_not_found_p
= 1;
19364 s
->font
= FRAME_FONT (s
->f
);
19367 /* Adjust base line for subscript/superscript text. */
19368 s
->ybase
+= s
->first_glyph
->voffset
;
19370 /* This glyph string must always be drawn with 16-bit functions. */
19373 return s
->gidx
+ s
->nchars
;
19377 /* Fill glyph string S from a sequence of character glyphs.
19379 FACE_ID is the face id of the string. START is the index of the
19380 first glyph to consider, END is the index of the last + 1.
19381 OVERLAPS non-zero means S should draw the foreground only, and use
19382 its physical height for clipping. See also draw_glyphs.
19384 Value is the index of the first glyph not in S. */
19387 fill_glyph_string (s
, face_id
, start
, end
, overlaps
)
19388 struct glyph_string
*s
;
19390 int start
, end
, overlaps
;
19392 struct glyph
*glyph
, *last
;
19394 int glyph_not_available_p
;
19396 xassert (s
->f
== XFRAME (s
->w
->frame
));
19397 xassert (s
->nchars
== 0);
19398 xassert (start
>= 0 && end
> start
);
19400 s
->for_overlaps
= overlaps
,
19401 glyph
= s
->row
->glyphs
[s
->area
] + start
;
19402 last
= s
->row
->glyphs
[s
->area
] + end
;
19403 voffset
= glyph
->voffset
;
19405 glyph_not_available_p
= glyph
->glyph_not_available_p
;
19407 while (glyph
< last
19408 && glyph
->type
== CHAR_GLYPH
19409 && glyph
->voffset
== voffset
19410 /* Same face id implies same font, nowadays. */
19411 && glyph
->face_id
== face_id
19412 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
19416 s
->face
= get_glyph_face_and_encoding (s
->f
, glyph
,
19417 s
->char2b
+ s
->nchars
,
19419 s
->two_byte_p
= two_byte_p
;
19421 xassert (s
->nchars
<= end
- start
);
19422 s
->width
+= glyph
->pixel_width
;
19426 s
->font
= s
->face
->font
;
19427 s
->font_info
= FONT_INFO_FROM_FACE (s
->f
, s
->face
);
19429 /* If the specified font could not be loaded, use the frame's font,
19430 but record the fact that we couldn't load it in
19431 S->font_not_found_p so that we can draw rectangles for the
19432 characters of the glyph string. */
19433 if (s
->font
== NULL
|| glyph_not_available_p
)
19435 s
->font_not_found_p
= 1;
19436 s
->font
= FRAME_FONT (s
->f
);
19439 /* Adjust base line for subscript/superscript text. */
19440 s
->ybase
+= voffset
;
19442 xassert (s
->face
&& s
->face
->gc
);
19443 return glyph
- s
->row
->glyphs
[s
->area
];
19447 /* Fill glyph string S from image glyph S->first_glyph. */
19450 fill_image_glyph_string (s
)
19451 struct glyph_string
*s
;
19453 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
19454 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
19456 s
->slice
= s
->first_glyph
->slice
;
19457 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
19458 s
->font
= s
->face
->font
;
19459 s
->width
= s
->first_glyph
->pixel_width
;
19461 /* Adjust base line for subscript/superscript text. */
19462 s
->ybase
+= s
->first_glyph
->voffset
;
19466 /* Fill glyph string S from a sequence of stretch glyphs.
19468 ROW is the glyph row in which the glyphs are found, AREA is the
19469 area within the row. START is the index of the first glyph to
19470 consider, END is the index of the last + 1.
19472 Value is the index of the first glyph not in S. */
19475 fill_stretch_glyph_string (s
, row
, area
, start
, end
)
19476 struct glyph_string
*s
;
19477 struct glyph_row
*row
;
19478 enum glyph_row_area area
;
19481 struct glyph
*glyph
, *last
;
19482 int voffset
, face_id
;
19484 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
19486 glyph
= s
->row
->glyphs
[s
->area
] + start
;
19487 last
= s
->row
->glyphs
[s
->area
] + end
;
19488 face_id
= glyph
->face_id
;
19489 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
19490 s
->font
= s
->face
->font
;
19491 s
->font_info
= FONT_INFO_FROM_FACE (s
->f
, s
->face
);
19492 s
->width
= glyph
->pixel_width
;
19494 voffset
= glyph
->voffset
;
19498 && glyph
->type
== STRETCH_GLYPH
19499 && glyph
->voffset
== voffset
19500 && glyph
->face_id
== face_id
);
19502 s
->width
+= glyph
->pixel_width
;
19504 /* Adjust base line for subscript/superscript text. */
19505 s
->ybase
+= voffset
;
19507 /* The case that face->gc == 0 is handled when drawing the glyph
19508 string by calling PREPARE_FACE_FOR_DISPLAY. */
19510 return glyph
- s
->row
->glyphs
[s
->area
];
19513 static XCharStruct
*
19514 get_per_char_metric (f
, font
, font_info
, char2b
, font_type
)
19517 struct font_info
*font_info
;
19521 #ifdef USE_FONT_BACKEND
19522 if (enable_font_backend
)
19524 static XCharStruct pcm_value
;
19525 unsigned code
= (XCHAR2B_BYTE1 (char2b
) << 8) | XCHAR2B_BYTE2 (char2b
);
19526 struct font
*fontp
;
19527 struct font_metrics metrics
;
19529 if (! font_info
|| code
== FONT_INVALID_CODE
)
19531 fontp
= (struct font
*) font_info
;
19532 fontp
->driver
->text_extents (fontp
, &code
, 1, &metrics
);
19533 pcm_value
.lbearing
= metrics
.lbearing
;
19534 pcm_value
.rbearing
= metrics
.rbearing
;
19535 pcm_value
.ascent
= metrics
.ascent
;
19536 pcm_value
.descent
= metrics
.descent
;
19537 pcm_value
.width
= metrics
.width
;
19540 #endif /* USE_FONT_BACKEND */
19541 return FRAME_RIF (f
)->per_char_metric (font
, char2b
, font_type
);
19545 Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
19546 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
19547 assumed to be zero. */
19550 x_get_glyph_overhangs (glyph
, f
, left
, right
)
19551 struct glyph
*glyph
;
19555 *left
= *right
= 0;
19557 if (glyph
->type
== CHAR_GLYPH
)
19561 struct font_info
*font_info
;
19565 face
= get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
19567 font_info
= FONT_INFO_FROM_FACE (f
, face
);
19568 if (font
/* ++KFS: Should this be font_info ? */
19569 && (pcm
= get_per_char_metric (f
, font
, font_info
, &char2b
, glyph
->font_type
)))
19571 if (pcm
->rbearing
> pcm
->width
)
19572 *right
= pcm
->rbearing
- pcm
->width
;
19573 if (pcm
->lbearing
< 0)
19574 *left
= -pcm
->lbearing
;
19577 else if (glyph
->type
== COMPOSITE_GLYPH
)
19579 struct composition
*cmp
= composition_table
[glyph
->u
.cmp_id
];
19581 *right
= cmp
->rbearing
- cmp
->pixel_width
;
19582 *left
= - cmp
->lbearing
;
19587 /* Return the index of the first glyph preceding glyph string S that
19588 is overwritten by S because of S's left overhang. Value is -1
19589 if no glyphs are overwritten. */
19592 left_overwritten (s
)
19593 struct glyph_string
*s
;
19597 if (s
->left_overhang
)
19600 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
19601 int first
= s
->first_glyph
- glyphs
;
19603 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
19604 x
-= glyphs
[i
].pixel_width
;
19615 /* Return the index of the first glyph preceding glyph string S that
19616 is overwriting S because of its right overhang. Value is -1 if no
19617 glyph in front of S overwrites S. */
19620 left_overwriting (s
)
19621 struct glyph_string
*s
;
19624 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
19625 int first
= s
->first_glyph
- glyphs
;
19629 for (i
= first
- 1; i
>= 0; --i
)
19632 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
19635 x
-= glyphs
[i
].pixel_width
;
19642 /* Return the index of the last glyph following glyph string S that is
19643 not overwritten by S because of S's right overhang. Value is -1 if
19644 no such glyph is found. */
19647 right_overwritten (s
)
19648 struct glyph_string
*s
;
19652 if (s
->right_overhang
)
19655 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
19656 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
19657 int end
= s
->row
->used
[s
->area
];
19659 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
19660 x
+= glyphs
[i
].pixel_width
;
19669 /* Return the index of the last glyph following glyph string S that
19670 overwrites S because of its left overhang. Value is negative
19671 if no such glyph is found. */
19674 right_overwriting (s
)
19675 struct glyph_string
*s
;
19678 int end
= s
->row
->used
[s
->area
];
19679 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
19680 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
19684 for (i
= first
; i
< end
; ++i
)
19687 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
19690 x
+= glyphs
[i
].pixel_width
;
19697 /* Set background width of glyph string S. START is the index of the
19698 first glyph following S. LAST_X is the right-most x-position + 1
19699 in the drawing area. */
19702 set_glyph_string_background_width (s
, start
, last_x
)
19703 struct glyph_string
*s
;
19707 /* If the face of this glyph string has to be drawn to the end of
19708 the drawing area, set S->extends_to_end_of_line_p. */
19710 if (start
== s
->row
->used
[s
->area
]
19711 && s
->area
== TEXT_AREA
19712 && ((s
->row
->fill_line_p
19713 && (s
->hl
== DRAW_NORMAL_TEXT
19714 || s
->hl
== DRAW_IMAGE_RAISED
19715 || s
->hl
== DRAW_IMAGE_SUNKEN
))
19716 || s
->hl
== DRAW_MOUSE_FACE
))
19717 s
->extends_to_end_of_line_p
= 1;
19719 /* If S extends its face to the end of the line, set its
19720 background_width to the distance to the right edge of the drawing
19722 if (s
->extends_to_end_of_line_p
)
19723 s
->background_width
= last_x
- s
->x
+ 1;
19725 s
->background_width
= s
->width
;
19729 /* Compute overhangs and x-positions for glyph string S and its
19730 predecessors, or successors. X is the starting x-position for S.
19731 BACKWARD_P non-zero means process predecessors. */
19734 compute_overhangs_and_x (s
, x
, backward_p
)
19735 struct glyph_string
*s
;
19743 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
19744 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
19754 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
19755 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
19765 /* The following macros are only called from draw_glyphs below.
19766 They reference the following parameters of that function directly:
19767 `w', `row', `area', and `overlap_p'
19768 as well as the following local variables:
19769 `s', `f', and `hdc' (in W32) */
19772 /* On W32, silently add local `hdc' variable to argument list of
19773 init_glyph_string. */
19774 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
19775 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
19777 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
19778 init_glyph_string (s, char2b, w, row, area, start, hl)
19781 /* Add a glyph string for a stretch glyph to the list of strings
19782 between HEAD and TAIL. START is the index of the stretch glyph in
19783 row area AREA of glyph row ROW. END is the index of the last glyph
19784 in that glyph row area. X is the current output position assigned
19785 to the new glyph string constructed. HL overrides that face of the
19786 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
19787 is the right-most x-position of the drawing area. */
19789 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
19790 and below -- keep them on one line. */
19791 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
19794 s = (struct glyph_string *) alloca (sizeof *s); \
19795 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
19796 START = fill_stretch_glyph_string (s, row, area, START, END); \
19797 append_glyph_string (&HEAD, &TAIL, s); \
19803 /* Add a glyph string for an image glyph to the list of strings
19804 between HEAD and TAIL. START is the index of the image glyph in
19805 row area AREA of glyph row ROW. END is the index of the last glyph
19806 in that glyph row area. X is the current output position assigned
19807 to the new glyph string constructed. HL overrides that face of the
19808 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
19809 is the right-most x-position of the drawing area. */
19811 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
19814 s = (struct glyph_string *) alloca (sizeof *s); \
19815 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
19816 fill_image_glyph_string (s); \
19817 append_glyph_string (&HEAD, &TAIL, s); \
19824 /* Add a glyph string for a sequence of character glyphs to the list
19825 of strings between HEAD and TAIL. START is the index of the first
19826 glyph in row area AREA of glyph row ROW that is part of the new
19827 glyph string. END is the index of the last glyph in that glyph row
19828 area. X is the current output position assigned to the new glyph
19829 string constructed. HL overrides that face of the glyph; e.g. it
19830 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
19831 right-most x-position of the drawing area. */
19833 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
19839 face_id = (row)->glyphs[area][START].face_id; \
19841 s = (struct glyph_string *) alloca (sizeof *s); \
19842 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
19843 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
19844 append_glyph_string (&HEAD, &TAIL, s); \
19846 START = fill_glyph_string (s, face_id, START, END, overlaps); \
19851 /* Add a glyph string for a composite sequence to the list of strings
19852 between HEAD and TAIL. START is the index of the first glyph in
19853 row area AREA of glyph row ROW that is part of the new glyph
19854 string. END is the index of the last glyph in that glyph row area.
19855 X is the current output position assigned to the new glyph string
19856 constructed. HL overrides that face of the glyph; e.g. it is
19857 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
19858 x-position of the drawing area. */
19860 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
19862 int face_id = (row)->glyphs[area][START].face_id; \
19863 struct face *base_face = FACE_FROM_ID (f, face_id); \
19864 int cmp_id = (row)->glyphs[area][START].u.cmp_id; \
19865 struct composition *cmp = composition_table[cmp_id]; \
19867 struct glyph_string *first_s; \
19870 char2b = (XChar2b *) alloca ((sizeof *char2b) * cmp->glyph_len); \
19871 base_face = base_face->ascii_face; \
19873 /* Make glyph_strings for each glyph sequence that is drawable by \
19874 the same face, and append them to HEAD/TAIL. */ \
19875 for (n = 0; n < cmp->glyph_len;) \
19877 s = (struct glyph_string *) alloca (sizeof *s); \
19878 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
19879 append_glyph_string (&(HEAD), &(TAIL), s); \
19885 n = fill_composite_glyph_string (s, base_face, overlaps); \
19893 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
19894 of AREA of glyph row ROW on window W between indices START and END.
19895 HL overrides the face for drawing glyph strings, e.g. it is
19896 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
19897 x-positions of the drawing area.
19899 This is an ugly monster macro construct because we must use alloca
19900 to allocate glyph strings (because draw_glyphs can be called
19901 asynchronously). */
19903 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
19906 HEAD = TAIL = NULL; \
19907 while (START < END) \
19909 struct glyph *first_glyph = (row)->glyphs[area] + START; \
19910 switch (first_glyph->type) \
19913 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
19917 case COMPOSITE_GLYPH: \
19918 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
19922 case STRETCH_GLYPH: \
19923 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
19927 case IMAGE_GLYPH: \
19928 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
19938 set_glyph_string_background_width (s, START, LAST_X); \
19946 /* Draw glyphs between START and END in AREA of ROW on window W,
19947 starting at x-position X. X is relative to AREA in W. HL is a
19948 face-override with the following meaning:
19950 DRAW_NORMAL_TEXT draw normally
19951 DRAW_CURSOR draw in cursor face
19952 DRAW_MOUSE_FACE draw in mouse face.
19953 DRAW_INVERSE_VIDEO draw in mode line face
19954 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
19955 DRAW_IMAGE_RAISED draw an image with a raised relief around it
19957 If OVERLAPS is non-zero, draw only the foreground of characters and
19958 clip to the physical height of ROW. Non-zero value also defines
19959 the overlapping part to be drawn:
19961 OVERLAPS_PRED overlap with preceding rows
19962 OVERLAPS_SUCC overlap with succeeding rows
19963 OVERLAPS_BOTH overlap with both preceding/succeeding rows
19964 OVERLAPS_ERASED_CURSOR overlap with erased cursor area
19966 Value is the x-position reached, relative to AREA of W. */
19969 draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, overlaps
)
19972 struct glyph_row
*row
;
19973 enum glyph_row_area area
;
19974 EMACS_INT start
, end
;
19975 enum draw_glyphs_face hl
;
19978 struct glyph_string
*head
, *tail
;
19979 struct glyph_string
*s
;
19980 struct glyph_string
*clip_head
= NULL
, *clip_tail
= NULL
;
19981 int last_x
, area_width
;
19984 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
19987 ALLOCATE_HDC (hdc
, f
);
19989 /* Let's rather be paranoid than getting a SEGV. */
19990 end
= min (end
, row
->used
[area
]);
19991 start
= max (0, start
);
19992 start
= min (end
, start
);
19994 /* Translate X to frame coordinates. Set last_x to the right
19995 end of the drawing area. */
19996 if (row
->full_width_p
)
19998 /* X is relative to the left edge of W, without scroll bars
20000 x
+= WINDOW_LEFT_EDGE_X (w
);
20001 last_x
= WINDOW_LEFT_EDGE_X (w
) + WINDOW_TOTAL_WIDTH (w
);
20005 int area_left
= window_box_left (w
, area
);
20007 area_width
= window_box_width (w
, area
);
20008 last_x
= area_left
+ area_width
;
20011 /* Build a doubly-linked list of glyph_string structures between
20012 head and tail from what we have to draw. Note that the macro
20013 BUILD_GLYPH_STRINGS will modify its start parameter. That's
20014 the reason we use a separate variable `i'. */
20016 BUILD_GLYPH_STRINGS (i
, end
, head
, tail
, hl
, x
, last_x
);
20018 x_reached
= tail
->x
+ tail
->background_width
;
20022 /* If there are any glyphs with lbearing < 0 or rbearing > width in
20023 the row, redraw some glyphs in front or following the glyph
20024 strings built above. */
20025 if (head
&& !overlaps
&& row
->contains_overlapping_glyphs_p
)
20028 struct glyph_string
*h
, *t
;
20030 /* Compute overhangs for all glyph strings. */
20031 if (FRAME_RIF (f
)->compute_glyph_string_overhangs
)
20032 for (s
= head
; s
; s
= s
->next
)
20033 FRAME_RIF (f
)->compute_glyph_string_overhangs (s
);
20035 /* Prepend glyph strings for glyphs in front of the first glyph
20036 string that are overwritten because of the first glyph
20037 string's left overhang. The background of all strings
20038 prepended must be drawn because the first glyph string
20040 i
= left_overwritten (head
);
20044 BUILD_GLYPH_STRINGS (j
, start
, h
, t
,
20045 DRAW_NORMAL_TEXT
, dummy_x
, last_x
);
20047 compute_overhangs_and_x (t
, head
->x
, 1);
20048 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
20052 /* Prepend glyph strings for glyphs in front of the first glyph
20053 string that overwrite that glyph string because of their
20054 right overhang. For these strings, only the foreground must
20055 be drawn, because it draws over the glyph string at `head'.
20056 The background must not be drawn because this would overwrite
20057 right overhangs of preceding glyphs for which no glyph
20059 i
= left_overwriting (head
);
20063 BUILD_GLYPH_STRINGS (i
, start
, h
, t
,
20064 DRAW_NORMAL_TEXT
, dummy_x
, last_x
);
20065 for (s
= h
; s
; s
= s
->next
)
20066 s
->background_filled_p
= 1;
20067 compute_overhangs_and_x (t
, head
->x
, 1);
20068 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
20071 /* Append glyphs strings for glyphs following the last glyph
20072 string tail that are overwritten by tail. The background of
20073 these strings has to be drawn because tail's foreground draws
20075 i
= right_overwritten (tail
);
20078 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
20079 DRAW_NORMAL_TEXT
, x
, last_x
);
20080 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
20081 append_glyph_string_lists (&head
, &tail
, h
, t
);
20085 /* Append glyph strings for glyphs following the last glyph
20086 string tail that overwrite tail. The foreground of such
20087 glyphs has to be drawn because it writes into the background
20088 of tail. The background must not be drawn because it could
20089 paint over the foreground of following glyphs. */
20090 i
= right_overwriting (tail
);
20094 i
++; /* We must include the Ith glyph. */
20095 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
20096 DRAW_NORMAL_TEXT
, x
, last_x
);
20097 for (s
= h
; s
; s
= s
->next
)
20098 s
->background_filled_p
= 1;
20099 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
20100 append_glyph_string_lists (&head
, &tail
, h
, t
);
20102 if (clip_head
|| clip_tail
)
20103 for (s
= head
; s
; s
= s
->next
)
20105 s
->clip_head
= clip_head
;
20106 s
->clip_tail
= clip_tail
;
20110 /* Draw all strings. */
20111 for (s
= head
; s
; s
= s
->next
)
20112 FRAME_RIF (f
)->draw_glyph_string (s
);
20114 if (area
== TEXT_AREA
20115 && !row
->full_width_p
20116 /* When drawing overlapping rows, only the glyph strings'
20117 foreground is drawn, which doesn't erase a cursor
20121 int x0
= clip_head
? clip_head
->x
: (head
? head
->x
: x
);
20122 int x1
= (clip_tail
? clip_tail
->x
+ clip_tail
->background_width
20123 : (tail
? tail
->x
+ tail
->background_width
: x
));
20125 int text_left
= window_box_left (w
, TEXT_AREA
);
20129 notice_overwritten_cursor (w
, TEXT_AREA
, x0
, x1
,
20130 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
20133 /* Value is the x-position up to which drawn, relative to AREA of W.
20134 This doesn't include parts drawn because of overhangs. */
20135 if (row
->full_width_p
)
20136 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
20138 x_reached
-= window_box_left (w
, area
);
20140 RELEASE_HDC (hdc
, f
);
20145 /* Expand row matrix if too narrow. Don't expand if area
20148 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
20150 if (!fonts_changed_p \
20151 && (it->glyph_row->glyphs[area] \
20152 < it->glyph_row->glyphs[area + 1])) \
20154 it->w->ncols_scale_factor++; \
20155 fonts_changed_p = 1; \
20159 /* Store one glyph for IT->char_to_display in IT->glyph_row.
20160 Called from x_produce_glyphs when IT->glyph_row is non-null. */
20166 struct glyph
*glyph
;
20167 enum glyph_row_area area
= it
->area
;
20169 xassert (it
->glyph_row
);
20170 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
20172 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
20173 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
20175 glyph
->charpos
= CHARPOS (it
->position
);
20176 glyph
->object
= it
->object
;
20177 glyph
->pixel_width
= it
->pixel_width
;
20178 glyph
->ascent
= it
->ascent
;
20179 glyph
->descent
= it
->descent
;
20180 glyph
->voffset
= it
->voffset
;
20181 glyph
->type
= CHAR_GLYPH
;
20182 glyph
->multibyte_p
= it
->multibyte_p
;
20183 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
20184 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
20185 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
20186 || it
->phys_descent
> it
->descent
);
20187 glyph
->padding_p
= 0;
20188 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
20189 glyph
->face_id
= it
->face_id
;
20190 glyph
->u
.ch
= it
->char_to_display
;
20191 glyph
->slice
= null_glyph_slice
;
20192 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
20193 ++it
->glyph_row
->used
[area
];
20196 IT_EXPAND_MATRIX_WIDTH (it
, area
);
20199 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
20200 Called from x_produce_glyphs when IT->glyph_row is non-null. */
20203 append_composite_glyph (it
)
20206 struct glyph
*glyph
;
20207 enum glyph_row_area area
= it
->area
;
20209 xassert (it
->glyph_row
);
20211 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
20212 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
20214 glyph
->charpos
= CHARPOS (it
->position
);
20215 glyph
->object
= it
->object
;
20216 glyph
->pixel_width
= it
->pixel_width
;
20217 glyph
->ascent
= it
->ascent
;
20218 glyph
->descent
= it
->descent
;
20219 glyph
->voffset
= it
->voffset
;
20220 glyph
->type
= COMPOSITE_GLYPH
;
20221 glyph
->multibyte_p
= it
->multibyte_p
;
20222 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
20223 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
20224 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
20225 || it
->phys_descent
> it
->descent
);
20226 glyph
->padding_p
= 0;
20227 glyph
->glyph_not_available_p
= 0;
20228 glyph
->face_id
= it
->face_id
;
20229 glyph
->u
.cmp_id
= it
->cmp_id
;
20230 glyph
->slice
= null_glyph_slice
;
20231 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
20232 ++it
->glyph_row
->used
[area
];
20235 IT_EXPAND_MATRIX_WIDTH (it
, area
);
20239 /* Change IT->ascent and IT->height according to the setting of
20243 take_vertical_position_into_account (it
)
20248 if (it
->voffset
< 0)
20249 /* Increase the ascent so that we can display the text higher
20251 it
->ascent
-= it
->voffset
;
20253 /* Increase the descent so that we can display the text lower
20255 it
->descent
+= it
->voffset
;
20260 /* Produce glyphs/get display metrics for the image IT is loaded with.
20261 See the description of struct display_iterator in dispextern.h for
20262 an overview of struct display_iterator. */
20265 produce_image_glyph (it
)
20270 int glyph_ascent
, crop
;
20271 struct glyph_slice slice
;
20273 xassert (it
->what
== IT_IMAGE
);
20275 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
20277 /* Make sure X resources of the face is loaded. */
20278 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
20280 if (it
->image_id
< 0)
20282 /* Fringe bitmap. */
20283 it
->ascent
= it
->phys_ascent
= 0;
20284 it
->descent
= it
->phys_descent
= 0;
20285 it
->pixel_width
= 0;
20290 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
20292 /* Make sure X resources of the image is loaded. */
20293 prepare_image_for_display (it
->f
, img
);
20295 slice
.x
= slice
.y
= 0;
20296 slice
.width
= img
->width
;
20297 slice
.height
= img
->height
;
20299 if (INTEGERP (it
->slice
.x
))
20300 slice
.x
= XINT (it
->slice
.x
);
20301 else if (FLOATP (it
->slice
.x
))
20302 slice
.x
= XFLOAT_DATA (it
->slice
.x
) * img
->width
;
20304 if (INTEGERP (it
->slice
.y
))
20305 slice
.y
= XINT (it
->slice
.y
);
20306 else if (FLOATP (it
->slice
.y
))
20307 slice
.y
= XFLOAT_DATA (it
->slice
.y
) * img
->height
;
20309 if (INTEGERP (it
->slice
.width
))
20310 slice
.width
= XINT (it
->slice
.width
);
20311 else if (FLOATP (it
->slice
.width
))
20312 slice
.width
= XFLOAT_DATA (it
->slice
.width
) * img
->width
;
20314 if (INTEGERP (it
->slice
.height
))
20315 slice
.height
= XINT (it
->slice
.height
);
20316 else if (FLOATP (it
->slice
.height
))
20317 slice
.height
= XFLOAT_DATA (it
->slice
.height
) * img
->height
;
20319 if (slice
.x
>= img
->width
)
20320 slice
.x
= img
->width
;
20321 if (slice
.y
>= img
->height
)
20322 slice
.y
= img
->height
;
20323 if (slice
.x
+ slice
.width
>= img
->width
)
20324 slice
.width
= img
->width
- slice
.x
;
20325 if (slice
.y
+ slice
.height
> img
->height
)
20326 slice
.height
= img
->height
- slice
.y
;
20328 if (slice
.width
== 0 || slice
.height
== 0)
20331 it
->ascent
= it
->phys_ascent
= glyph_ascent
= image_ascent (img
, face
, &slice
);
20333 it
->descent
= slice
.height
- glyph_ascent
;
20335 it
->descent
+= img
->vmargin
;
20336 if (slice
.y
+ slice
.height
== img
->height
)
20337 it
->descent
+= img
->vmargin
;
20338 it
->phys_descent
= it
->descent
;
20340 it
->pixel_width
= slice
.width
;
20342 it
->pixel_width
+= img
->hmargin
;
20343 if (slice
.x
+ slice
.width
== img
->width
)
20344 it
->pixel_width
+= img
->hmargin
;
20346 /* It's quite possible for images to have an ascent greater than
20347 their height, so don't get confused in that case. */
20348 if (it
->descent
< 0)
20351 #if 0 /* this breaks image tiling */
20352 /* If this glyph is alone on the last line, adjust it.ascent to minimum row ascent. */
20353 int face_ascent
= face
->font
? FONT_BASE (face
->font
) : FRAME_BASELINE_OFFSET (it
->f
);
20354 if (face_ascent
> it
->ascent
)
20355 it
->ascent
= it
->phys_ascent
= face_ascent
;
20360 if (face
->box
!= FACE_NO_BOX
)
20362 if (face
->box_line_width
> 0)
20365 it
->ascent
+= face
->box_line_width
;
20366 if (slice
.y
+ slice
.height
== img
->height
)
20367 it
->descent
+= face
->box_line_width
;
20370 if (it
->start_of_box_run_p
&& slice
.x
== 0)
20371 it
->pixel_width
+= eabs (face
->box_line_width
);
20372 if (it
->end_of_box_run_p
&& slice
.x
+ slice
.width
== img
->width
)
20373 it
->pixel_width
+= eabs (face
->box_line_width
);
20376 take_vertical_position_into_account (it
);
20378 /* Automatically crop wide image glyphs at right edge so we can
20379 draw the cursor on same display row. */
20380 if ((crop
= it
->pixel_width
- (it
->last_visible_x
- it
->current_x
), crop
> 0)
20381 && (it
->hpos
== 0 || it
->pixel_width
> it
->last_visible_x
/ 4))
20383 it
->pixel_width
-= crop
;
20384 slice
.width
-= crop
;
20389 struct glyph
*glyph
;
20390 enum glyph_row_area area
= it
->area
;
20392 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
20393 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
20395 glyph
->charpos
= CHARPOS (it
->position
);
20396 glyph
->object
= it
->object
;
20397 glyph
->pixel_width
= it
->pixel_width
;
20398 glyph
->ascent
= glyph_ascent
;
20399 glyph
->descent
= it
->descent
;
20400 glyph
->voffset
= it
->voffset
;
20401 glyph
->type
= IMAGE_GLYPH
;
20402 glyph
->multibyte_p
= it
->multibyte_p
;
20403 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
20404 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
20405 glyph
->overlaps_vertically_p
= 0;
20406 glyph
->padding_p
= 0;
20407 glyph
->glyph_not_available_p
= 0;
20408 glyph
->face_id
= it
->face_id
;
20409 glyph
->u
.img_id
= img
->id
;
20410 glyph
->slice
= slice
;
20411 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
20412 ++it
->glyph_row
->used
[area
];
20415 IT_EXPAND_MATRIX_WIDTH (it
, area
);
20420 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
20421 of the glyph, WIDTH and HEIGHT are the width and height of the
20422 stretch. ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT). */
20425 append_stretch_glyph (it
, object
, width
, height
, ascent
)
20427 Lisp_Object object
;
20431 struct glyph
*glyph
;
20432 enum glyph_row_area area
= it
->area
;
20434 xassert (ascent
>= 0 && ascent
<= height
);
20436 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
20437 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
20439 glyph
->charpos
= CHARPOS (it
->position
);
20440 glyph
->object
= object
;
20441 glyph
->pixel_width
= width
;
20442 glyph
->ascent
= ascent
;
20443 glyph
->descent
= height
- ascent
;
20444 glyph
->voffset
= it
->voffset
;
20445 glyph
->type
= STRETCH_GLYPH
;
20446 glyph
->multibyte_p
= it
->multibyte_p
;
20447 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
20448 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
20449 glyph
->overlaps_vertically_p
= 0;
20450 glyph
->padding_p
= 0;
20451 glyph
->glyph_not_available_p
= 0;
20452 glyph
->face_id
= it
->face_id
;
20453 glyph
->u
.stretch
.ascent
= ascent
;
20454 glyph
->u
.stretch
.height
= height
;
20455 glyph
->slice
= null_glyph_slice
;
20456 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
20457 ++it
->glyph_row
->used
[area
];
20460 IT_EXPAND_MATRIX_WIDTH (it
, area
);
20464 /* Produce a stretch glyph for iterator IT. IT->object is the value
20465 of the glyph property displayed. The value must be a list
20466 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
20469 1. `:width WIDTH' specifies that the space should be WIDTH *
20470 canonical char width wide. WIDTH may be an integer or floating
20473 2. `:relative-width FACTOR' specifies that the width of the stretch
20474 should be computed from the width of the first character having the
20475 `glyph' property, and should be FACTOR times that width.
20477 3. `:align-to HPOS' specifies that the space should be wide enough
20478 to reach HPOS, a value in canonical character units.
20480 Exactly one of the above pairs must be present.
20482 4. `:height HEIGHT' specifies that the height of the stretch produced
20483 should be HEIGHT, measured in canonical character units.
20485 5. `:relative-height FACTOR' specifies that the height of the
20486 stretch should be FACTOR times the height of the characters having
20487 the glyph property.
20489 Either none or exactly one of 4 or 5 must be present.
20491 6. `:ascent ASCENT' specifies that ASCENT percent of the height
20492 of the stretch should be used for the ascent of the stretch.
20493 ASCENT must be in the range 0 <= ASCENT <= 100. */
20496 produce_stretch_glyph (it
)
20499 /* (space :width WIDTH :height HEIGHT ...) */
20500 Lisp_Object prop
, plist
;
20501 int width
= 0, height
= 0, align_to
= -1;
20502 int zero_width_ok_p
= 0, zero_height_ok_p
= 0;
20505 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
20506 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
20508 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
20510 /* List should start with `space'. */
20511 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
20512 plist
= XCDR (it
->object
);
20514 /* Compute the width of the stretch. */
20515 if ((prop
= Fplist_get (plist
, QCwidth
), !NILP (prop
))
20516 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, 0))
20518 /* Absolute width `:width WIDTH' specified and valid. */
20519 zero_width_ok_p
= 1;
20522 else if (prop
= Fplist_get (plist
, QCrelative_width
),
20525 /* Relative width `:relative-width FACTOR' specified and valid.
20526 Compute the width of the characters having the `glyph'
20529 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
20532 if (it
->multibyte_p
)
20534 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
20535 - IT_BYTEPOS (*it
));
20536 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
20539 it2
.c
= *p
, it2
.len
= 1;
20541 it2
.glyph_row
= NULL
;
20542 it2
.what
= IT_CHARACTER
;
20543 x_produce_glyphs (&it2
);
20544 width
= NUMVAL (prop
) * it2
.pixel_width
;
20546 else if ((prop
= Fplist_get (plist
, QCalign_to
), !NILP (prop
))
20547 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, &align_to
))
20549 if (it
->glyph_row
== NULL
|| !it
->glyph_row
->mode_line_p
)
20550 align_to
= (align_to
< 0
20552 : align_to
- window_box_left_offset (it
->w
, TEXT_AREA
));
20553 else if (align_to
< 0)
20554 align_to
= window_box_left_offset (it
->w
, TEXT_AREA
);
20555 width
= max (0, (int)tem
+ align_to
- it
->current_x
);
20556 zero_width_ok_p
= 1;
20559 /* Nothing specified -> width defaults to canonical char width. */
20560 width
= FRAME_COLUMN_WIDTH (it
->f
);
20562 if (width
<= 0 && (width
< 0 || !zero_width_ok_p
))
20565 /* Compute height. */
20566 if ((prop
= Fplist_get (plist
, QCheight
), !NILP (prop
))
20567 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
20570 zero_height_ok_p
= 1;
20572 else if (prop
= Fplist_get (plist
, QCrelative_height
),
20574 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
20576 height
= FONT_HEIGHT (font
);
20578 if (height
<= 0 && (height
< 0 || !zero_height_ok_p
))
20581 /* Compute percentage of height used for ascent. If
20582 `:ascent ASCENT' is present and valid, use that. Otherwise,
20583 derive the ascent from the font in use. */
20584 if (prop
= Fplist_get (plist
, QCascent
),
20585 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
20586 ascent
= height
* NUMVAL (prop
) / 100.0;
20587 else if (!NILP (prop
)
20588 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
20589 ascent
= min (max (0, (int)tem
), height
);
20591 ascent
= (height
* FONT_BASE (font
)) / FONT_HEIGHT (font
);
20593 if (width
> 0 && !it
->truncate_lines_p
20594 && it
->current_x
+ width
> it
->last_visible_x
)
20595 width
= it
->last_visible_x
- it
->current_x
- 1;
20597 if (width
> 0 && height
> 0 && it
->glyph_row
)
20599 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
20600 if (!STRINGP (object
))
20601 object
= it
->w
->buffer
;
20602 append_stretch_glyph (it
, object
, width
, height
, ascent
);
20605 it
->pixel_width
= width
;
20606 it
->ascent
= it
->phys_ascent
= ascent
;
20607 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
20608 it
->nglyphs
= width
> 0 && height
> 0 ? 1 : 0;
20610 take_vertical_position_into_account (it
);
20613 /* Get line-height and line-spacing property at point.
20614 If line-height has format (HEIGHT TOTAL), return TOTAL
20615 in TOTAL_HEIGHT. */
20618 get_line_height_property (it
, prop
)
20622 Lisp_Object position
;
20624 if (STRINGP (it
->object
))
20625 position
= make_number (IT_STRING_CHARPOS (*it
));
20626 else if (BUFFERP (it
->object
))
20627 position
= make_number (IT_CHARPOS (*it
));
20631 return Fget_char_property (position
, prop
, it
->object
);
20634 /* Calculate line-height and line-spacing properties.
20635 An integer value specifies explicit pixel value.
20636 A float value specifies relative value to current face height.
20637 A cons (float . face-name) specifies relative value to
20638 height of specified face font.
20640 Returns height in pixels, or nil. */
20644 calc_line_height_property (it
, val
, font
, boff
, override
)
20648 int boff
, override
;
20650 Lisp_Object face_name
= Qnil
;
20651 int ascent
, descent
, height
;
20653 if (NILP (val
) || INTEGERP (val
) || (override
&& EQ (val
, Qt
)))
20658 face_name
= XCAR (val
);
20660 if (!NUMBERP (val
))
20661 val
= make_number (1);
20662 if (NILP (face_name
))
20664 height
= it
->ascent
+ it
->descent
;
20669 if (NILP (face_name
))
20671 font
= FRAME_FONT (it
->f
);
20672 boff
= FRAME_BASELINE_OFFSET (it
->f
);
20674 else if (EQ (face_name
, Qt
))
20682 struct font_info
*font_info
;
20684 face_id
= lookup_named_face (it
->f
, face_name
, 0);
20686 return make_number (-1);
20688 face
= FACE_FROM_ID (it
->f
, face_id
);
20691 return make_number (-1);
20693 font_info
= FONT_INFO_FROM_FACE (it
->f
, face
);
20694 boff
= font_info
->baseline_offset
;
20695 if (font_info
->vertical_centering
)
20696 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
20699 ascent
= FONT_BASE (font
) + boff
;
20700 descent
= FONT_DESCENT (font
) - boff
;
20704 it
->override_ascent
= ascent
;
20705 it
->override_descent
= descent
;
20706 it
->override_boff
= boff
;
20709 height
= ascent
+ descent
;
20713 height
= (int)(XFLOAT_DATA (val
) * height
);
20714 else if (INTEGERP (val
))
20715 height
*= XINT (val
);
20717 return make_number (height
);
20722 Produce glyphs/get display metrics for the display element IT is
20723 loaded with. See the description of struct it in dispextern.h
20724 for an overview of struct it. */
20727 x_produce_glyphs (it
)
20730 int extra_line_spacing
= it
->extra_line_spacing
;
20732 it
->glyph_not_available_p
= 0;
20734 if (it
->what
== IT_CHARACTER
)
20738 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
20740 int font_not_found_p
;
20741 struct font_info
*font_info
;
20742 int boff
; /* baseline offset */
20743 /* We may change it->multibyte_p upon unibyte<->multibyte
20744 conversion. So, save the current value now and restore it
20747 Note: It seems that we don't have to record multibyte_p in
20748 struct glyph because the character code itself tells if or
20749 not the character is multibyte. Thus, in the future, we must
20750 consider eliminating the field `multibyte_p' in the struct
20752 int saved_multibyte_p
= it
->multibyte_p
;
20754 /* Maybe translate single-byte characters to multibyte, or the
20756 it
->char_to_display
= it
->c
;
20757 if (!ASCII_BYTE_P (it
->c
)
20758 && ! it
->multibyte_p
)
20760 if (SINGLE_BYTE_CHAR_P (it
->c
)
20761 && unibyte_display_via_language_environment
)
20762 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
20763 if (! SINGLE_BYTE_CHAR_P (it
->char_to_display
))
20765 it
->multibyte_p
= 1;
20766 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
,
20768 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
20772 /* Get font to use. Encode IT->char_to_display. */
20773 get_char_face_and_encoding (it
->f
, it
->char_to_display
, it
->face_id
,
20774 &char2b
, it
->multibyte_p
, 0);
20777 /* When no suitable font found, use the default font. */
20778 font_not_found_p
= font
== NULL
;
20779 if (font_not_found_p
)
20781 font
= FRAME_FONT (it
->f
);
20782 boff
= FRAME_BASELINE_OFFSET (it
->f
);
20787 font_info
= FONT_INFO_FROM_FACE (it
->f
, face
);
20788 boff
= font_info
->baseline_offset
;
20789 if (font_info
->vertical_centering
)
20790 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
20793 if (it
->char_to_display
>= ' '
20794 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
20796 /* Either unibyte or ASCII. */
20801 pcm
= get_per_char_metric (it
->f
, font
, font_info
, &char2b
,
20802 FONT_TYPE_FOR_UNIBYTE (font
, it
->char_to_display
));
20804 if (it
->override_ascent
>= 0)
20806 it
->ascent
= it
->override_ascent
;
20807 it
->descent
= it
->override_descent
;
20808 boff
= it
->override_boff
;
20812 it
->ascent
= FONT_BASE (font
) + boff
;
20813 it
->descent
= FONT_DESCENT (font
) - boff
;
20818 it
->phys_ascent
= pcm
->ascent
+ boff
;
20819 it
->phys_descent
= pcm
->descent
- boff
;
20820 it
->pixel_width
= pcm
->width
;
20824 it
->glyph_not_available_p
= 1;
20825 it
->phys_ascent
= it
->ascent
;
20826 it
->phys_descent
= it
->descent
;
20827 it
->pixel_width
= FONT_WIDTH (font
);
20830 if (it
->constrain_row_ascent_descent_p
)
20832 if (it
->descent
> it
->max_descent
)
20834 it
->ascent
+= it
->descent
- it
->max_descent
;
20835 it
->descent
= it
->max_descent
;
20837 if (it
->ascent
> it
->max_ascent
)
20839 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
20840 it
->ascent
= it
->max_ascent
;
20842 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
20843 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
20844 extra_line_spacing
= 0;
20847 /* If this is a space inside a region of text with
20848 `space-width' property, change its width. */
20849 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
20851 it
->pixel_width
*= XFLOATINT (it
->space_width
);
20853 /* If face has a box, add the box thickness to the character
20854 height. If character has a box line to the left and/or
20855 right, add the box line width to the character's width. */
20856 if (face
->box
!= FACE_NO_BOX
)
20858 int thick
= face
->box_line_width
;
20862 it
->ascent
+= thick
;
20863 it
->descent
+= thick
;
20868 if (it
->start_of_box_run_p
)
20869 it
->pixel_width
+= thick
;
20870 if (it
->end_of_box_run_p
)
20871 it
->pixel_width
+= thick
;
20874 /* If face has an overline, add the height of the overline
20875 (1 pixel) and a 1 pixel margin to the character height. */
20876 if (face
->overline_p
)
20877 it
->ascent
+= overline_margin
;
20879 if (it
->constrain_row_ascent_descent_p
)
20881 if (it
->ascent
> it
->max_ascent
)
20882 it
->ascent
= it
->max_ascent
;
20883 if (it
->descent
> it
->max_descent
)
20884 it
->descent
= it
->max_descent
;
20887 take_vertical_position_into_account (it
);
20889 /* If we have to actually produce glyphs, do it. */
20894 /* Translate a space with a `space-width' property
20895 into a stretch glyph. */
20896 int ascent
= (((it
->ascent
+ it
->descent
) * FONT_BASE (font
))
20897 / FONT_HEIGHT (font
));
20898 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
20899 it
->ascent
+ it
->descent
, ascent
);
20904 /* If characters with lbearing or rbearing are displayed
20905 in this line, record that fact in a flag of the
20906 glyph row. This is used to optimize X output code. */
20907 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
20908 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
20911 else if (it
->char_to_display
== '\n')
20913 /* A newline has no width but we need the height of the line.
20914 But if previous part of the line set a height, don't
20915 increase that height */
20917 Lisp_Object height
;
20918 Lisp_Object total_height
= Qnil
;
20920 it
->override_ascent
= -1;
20921 it
->pixel_width
= 0;
20924 height
= get_line_height_property(it
, Qline_height
);
20925 /* Split (line-height total-height) list */
20927 && CONSP (XCDR (height
))
20928 && NILP (XCDR (XCDR (height
))))
20930 total_height
= XCAR (XCDR (height
));
20931 height
= XCAR (height
);
20933 height
= calc_line_height_property(it
, height
, font
, boff
, 1);
20935 if (it
->override_ascent
>= 0)
20937 it
->ascent
= it
->override_ascent
;
20938 it
->descent
= it
->override_descent
;
20939 boff
= it
->override_boff
;
20943 it
->ascent
= FONT_BASE (font
) + boff
;
20944 it
->descent
= FONT_DESCENT (font
) - boff
;
20947 if (EQ (height
, Qt
))
20949 if (it
->descent
> it
->max_descent
)
20951 it
->ascent
+= it
->descent
- it
->max_descent
;
20952 it
->descent
= it
->max_descent
;
20954 if (it
->ascent
> it
->max_ascent
)
20956 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
20957 it
->ascent
= it
->max_ascent
;
20959 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
20960 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
20961 it
->constrain_row_ascent_descent_p
= 1;
20962 extra_line_spacing
= 0;
20966 Lisp_Object spacing
;
20968 it
->phys_ascent
= it
->ascent
;
20969 it
->phys_descent
= it
->descent
;
20971 if ((it
->max_ascent
> 0 || it
->max_descent
> 0)
20972 && face
->box
!= FACE_NO_BOX
20973 && face
->box_line_width
> 0)
20975 it
->ascent
+= face
->box_line_width
;
20976 it
->descent
+= face
->box_line_width
;
20979 && XINT (height
) > it
->ascent
+ it
->descent
)
20980 it
->ascent
= XINT (height
) - it
->descent
;
20982 if (!NILP (total_height
))
20983 spacing
= calc_line_height_property(it
, total_height
, font
, boff
, 0);
20986 spacing
= get_line_height_property(it
, Qline_spacing
);
20987 spacing
= calc_line_height_property(it
, spacing
, font
, boff
, 0);
20989 if (INTEGERP (spacing
))
20991 extra_line_spacing
= XINT (spacing
);
20992 if (!NILP (total_height
))
20993 extra_line_spacing
-= (it
->phys_ascent
+ it
->phys_descent
);
20997 else if (it
->char_to_display
== '\t')
20999 int tab_width
= it
->tab_width
* FRAME_SPACE_WIDTH (it
->f
);
21000 int x
= it
->current_x
+ it
->continuation_lines_width
;
21001 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
21003 /* If the distance from the current position to the next tab
21004 stop is less than a space character width, use the
21005 tab stop after that. */
21006 if (next_tab_x
- x
< FRAME_SPACE_WIDTH (it
->f
))
21007 next_tab_x
+= tab_width
;
21009 it
->pixel_width
= next_tab_x
- x
;
21011 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
21012 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
21016 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
21017 it
->ascent
+ it
->descent
, it
->ascent
);
21022 /* A multi-byte character. Assume that the display width of the
21023 character is the width of the character multiplied by the
21024 width of the font. */
21026 /* If we found a font, this font should give us the right
21027 metrics. If we didn't find a font, use the frame's
21028 default font and calculate the width of the character by
21029 multiplying the width of font by the width of the
21032 pcm
= get_per_char_metric (it
->f
, font
, font_info
, &char2b
,
21033 FONT_TYPE_FOR_MULTIBYTE (font
, it
->c
));
21035 if (font_not_found_p
|| !pcm
)
21037 int char_width
= CHAR_WIDTH (it
->char_to_display
);
21039 if (char_width
== 0)
21040 /* This is a non spacing character. But, as we are
21041 going to display an empty box, the box must occupy
21042 at least one column. */
21044 it
->glyph_not_available_p
= 1;
21045 it
->pixel_width
= FRAME_COLUMN_WIDTH (it
->f
) * char_width
;
21046 it
->phys_ascent
= FONT_BASE (font
) + boff
;
21047 it
->phys_descent
= FONT_DESCENT (font
) - boff
;
21051 it
->pixel_width
= pcm
->width
;
21052 it
->phys_ascent
= pcm
->ascent
+ boff
;
21053 it
->phys_descent
= pcm
->descent
- boff
;
21055 && (pcm
->lbearing
< 0
21056 || pcm
->rbearing
> pcm
->width
))
21057 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
21060 it
->ascent
= FONT_BASE (font
) + boff
;
21061 it
->descent
= FONT_DESCENT (font
) - boff
;
21062 if (face
->box
!= FACE_NO_BOX
)
21064 int thick
= face
->box_line_width
;
21068 it
->ascent
+= thick
;
21069 it
->descent
+= thick
;
21074 if (it
->start_of_box_run_p
)
21075 it
->pixel_width
+= thick
;
21076 if (it
->end_of_box_run_p
)
21077 it
->pixel_width
+= thick
;
21080 /* If face has an overline, add the height of the overline
21081 (1 pixel) and a 1 pixel margin to the character height. */
21082 if (face
->overline_p
)
21083 it
->ascent
+= overline_margin
;
21085 take_vertical_position_into_account (it
);
21090 it
->multibyte_p
= saved_multibyte_p
;
21092 else if (it
->what
== IT_COMPOSITION
)
21094 /* Note: A composition is represented as one glyph in the
21095 glyph matrix. There are no padding glyphs.
21097 Important is that pixel_width, ascent, and descent are the
21098 values of what is drawn by draw_glyphs (i.e. the values of
21099 the overall glyphs composed). */
21100 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
21101 int boff
; /* baseline offset */
21102 struct composition
*cmp
= composition_table
[it
->cmp_id
];
21103 int glyph_len
= cmp
->glyph_len
;
21104 XFontStruct
*font
= face
->font
;
21108 #ifdef USE_FONT_BACKEND
21109 if (cmp
->method
== COMPOSITION_WITH_GLYPH_STRING
)
21111 if (! cmp
->font
|| cmp
->font
!= font
)
21112 font_prepare_composition (cmp
);
21115 #endif /* USE_FONT_BACKEND */
21116 /* If we have not yet calculated pixel size data of glyphs of
21117 the composition for the current face font, calculate them
21118 now. Theoretically, we have to check all fonts for the
21119 glyphs, but that requires much time and memory space. So,
21120 here we check only the font of the first glyph. This leads
21121 to incorrect display, but it's very rare, and C-l (recenter)
21122 can correct the display anyway. */
21123 if (! cmp
->font
|| cmp
->font
!= font
)
21125 /* Ascent and descent of the font of the first character
21126 of this composition (adjusted by baseline offset).
21127 Ascent and descent of overall glyphs should not be less
21128 than them respectively. */
21129 int font_ascent
, font_descent
, font_height
;
21130 /* Bounding box of the overall glyphs. */
21131 int leftmost
, rightmost
, lowest
, highest
;
21132 int lbearing
, rbearing
;
21133 int i
, width
, ascent
, descent
;
21134 int left_padded
= 0, right_padded
= 0;
21139 int font_not_found_p
;
21140 struct font_info
*font_info
;
21143 for (glyph_len
= cmp
->glyph_len
; glyph_len
> 0; glyph_len
--)
21144 if ((c
= COMPOSITION_GLYPH (cmp
, glyph_len
- 1)) != '\t')
21146 if (glyph_len
< cmp
->glyph_len
)
21148 for (i
= 0; i
< glyph_len
; i
++)
21150 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
21152 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
21157 pos
= (STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
21158 : IT_CHARPOS (*it
));
21159 /* When no suitable font found, use the default font. */
21160 font_not_found_p
= font
== NULL
;
21161 if (font_not_found_p
)
21163 face
= face
->ascii_face
;
21166 font_info
= FONT_INFO_FROM_FACE (it
->f
, face
);
21167 boff
= font_info
->baseline_offset
;
21168 if (font_info
->vertical_centering
)
21169 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
21170 font_ascent
= FONT_BASE (font
) + boff
;
21171 font_descent
= FONT_DESCENT (font
) - boff
;
21172 font_height
= FONT_HEIGHT (font
);
21174 cmp
->font
= (void *) font
;
21177 if (! font_not_found_p
)
21179 get_char_face_and_encoding (it
->f
, c
, it
->face_id
,
21180 &char2b
, it
->multibyte_p
, 0);
21181 pcm
= get_per_char_metric (it
->f
, font
, font_info
, &char2b
,
21182 FONT_TYPE_FOR_MULTIBYTE (font
, c
));
21185 /* Initialize the bounding box. */
21188 width
= pcm
->width
;
21189 ascent
= pcm
->ascent
;
21190 descent
= pcm
->descent
;
21191 lbearing
= pcm
->lbearing
;
21192 rbearing
= pcm
->rbearing
;
21196 width
= FONT_WIDTH (font
);
21197 ascent
= FONT_BASE (font
);
21198 descent
= FONT_DESCENT (font
);
21205 lowest
= - descent
+ boff
;
21206 highest
= ascent
+ boff
;
21208 if (! font_not_found_p
21209 && font_info
->default_ascent
21210 && CHAR_TABLE_P (Vuse_default_ascent
)
21211 && !NILP (Faref (Vuse_default_ascent
,
21212 make_number (it
->char_to_display
))))
21213 highest
= font_info
->default_ascent
+ boff
;
21215 /* Draw the first glyph at the normal position. It may be
21216 shifted to right later if some other glyphs are drawn
21218 cmp
->offsets
[i
* 2] = 0;
21219 cmp
->offsets
[i
* 2 + 1] = boff
;
21220 cmp
->lbearing
= lbearing
;
21221 cmp
->rbearing
= rbearing
;
21223 /* Set cmp->offsets for the remaining glyphs. */
21224 for (i
++; i
< glyph_len
; i
++)
21226 int left
, right
, btm
, top
;
21227 int ch
= COMPOSITION_GLYPH (cmp
, i
);
21229 struct face
*this_face
;
21234 face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
, pos
, it
->string
);
21235 this_face
= FACE_FROM_ID (it
->f
, face_id
);
21236 font
= this_face
->font
;
21242 font_info
= FONT_INFO_FROM_FACE (it
->f
, this_face
);
21243 this_boff
= font_info
->baseline_offset
;
21244 if (font_info
->vertical_centering
)
21245 this_boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
21246 get_char_face_and_encoding (it
->f
, ch
, face_id
,
21247 &char2b
, it
->multibyte_p
, 0);
21248 pcm
= get_per_char_metric (it
->f
, font
, font_info
, &char2b
,
21249 FONT_TYPE_FOR_MULTIBYTE (font
,
21253 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
21256 width
= pcm
->width
;
21257 ascent
= pcm
->ascent
;
21258 descent
= pcm
->descent
;
21259 lbearing
= pcm
->lbearing
;
21260 rbearing
= pcm
->rbearing
;
21261 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
21263 /* Relative composition with or without
21264 alternate chars. */
21265 left
= (leftmost
+ rightmost
- width
) / 2;
21266 btm
= - descent
+ boff
;
21267 if (font_info
->relative_compose
21268 && (! CHAR_TABLE_P (Vignore_relative_composition
)
21269 || NILP (Faref (Vignore_relative_composition
,
21270 make_number (ch
)))))
21273 if (- descent
>= font_info
->relative_compose
)
21274 /* One extra pixel between two glyphs. */
21276 else if (ascent
<= 0)
21277 /* One extra pixel between two glyphs. */
21278 btm
= lowest
- 1 - ascent
- descent
;
21283 /* A composition rule is specified by an integer
21284 value that encodes global and new reference
21285 points (GREF and NREF). GREF and NREF are
21286 specified by numbers as below:
21288 0---1---2 -- ascent
21292 9--10--11 -- center
21294 ---3---4---5--- baseline
21296 6---7---8 -- descent
21298 int rule
= COMPOSITION_RULE (cmp
, i
);
21299 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
, xoff
, yoff
;
21301 COMPOSITION_DECODE_RULE (rule
, gref
, nref
, xoff
, yoff
);
21302 grefx
= gref
% 3, nrefx
= nref
% 3;
21303 grefy
= gref
/ 3, nrefy
= nref
/ 3;
21305 xoff
= font_height
* (xoff
- 128) / 256;
21307 yoff
= font_height
* (yoff
- 128) / 256;
21310 + grefx
* (rightmost
- leftmost
) / 2
21311 - nrefx
* width
/ 2
21314 btm
= ((grefy
== 0 ? highest
21316 : grefy
== 2 ? lowest
21317 : (highest
+ lowest
) / 2)
21318 - (nrefy
== 0 ? ascent
+ descent
21319 : nrefy
== 1 ? descent
- boff
21321 : (ascent
+ descent
) / 2)
21325 cmp
->offsets
[i
* 2] = left
;
21326 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
21328 /* Update the bounding box of the overall glyphs. */
21331 right
= left
+ width
;
21332 if (left
< leftmost
)
21334 if (right
> rightmost
)
21337 top
= btm
+ descent
+ ascent
;
21343 if (cmp
->lbearing
> left
+ lbearing
)
21344 cmp
->lbearing
= left
+ lbearing
;
21345 if (cmp
->rbearing
< left
+ rbearing
)
21346 cmp
->rbearing
= left
+ rbearing
;
21350 /* If there are glyphs whose x-offsets are negative,
21351 shift all glyphs to the right and make all x-offsets
21355 for (i
= 0; i
< cmp
->glyph_len
; i
++)
21356 cmp
->offsets
[i
* 2] -= leftmost
;
21357 rightmost
-= leftmost
;
21358 cmp
->lbearing
-= leftmost
;
21359 cmp
->rbearing
-= leftmost
;
21362 if (left_padded
&& cmp
->lbearing
< 0)
21364 for (i
= 0; i
< cmp
->glyph_len
; i
++)
21365 cmp
->offsets
[i
* 2] -= cmp
->lbearing
;
21366 rightmost
-= cmp
->lbearing
;
21367 cmp
->rbearing
-= cmp
->lbearing
;
21370 if (right_padded
&& rightmost
< cmp
->rbearing
)
21372 rightmost
= cmp
->rbearing
;
21375 cmp
->pixel_width
= rightmost
;
21376 cmp
->ascent
= highest
;
21377 cmp
->descent
= - lowest
;
21378 if (cmp
->ascent
< font_ascent
)
21379 cmp
->ascent
= font_ascent
;
21380 if (cmp
->descent
< font_descent
)
21381 cmp
->descent
= font_descent
;
21385 && (cmp
->lbearing
< 0
21386 || cmp
->rbearing
> cmp
->pixel_width
))
21387 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
21389 it
->pixel_width
= cmp
->pixel_width
;
21390 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
21391 it
->descent
= it
->phys_descent
= cmp
->descent
;
21393 if (face
->box
!= FACE_NO_BOX
)
21395 int thick
= face
->box_line_width
;
21399 it
->ascent
+= thick
;
21400 it
->descent
+= thick
;
21405 if (it
->start_of_box_run_p
)
21406 it
->pixel_width
+= thick
;
21407 if (it
->end_of_box_run_p
)
21408 it
->pixel_width
+= thick
;
21411 /* If face has an overline, add the height of the overline
21412 (1 pixel) and a 1 pixel margin to the character height. */
21413 if (face
->overline_p
)
21414 it
->ascent
+= overline_margin
;
21416 take_vertical_position_into_account (it
);
21419 append_composite_glyph (it
);
21421 else if (it
->what
== IT_IMAGE
)
21422 produce_image_glyph (it
);
21423 else if (it
->what
== IT_STRETCH
)
21424 produce_stretch_glyph (it
);
21426 /* Accumulate dimensions. Note: can't assume that it->descent > 0
21427 because this isn't true for images with `:ascent 100'. */
21428 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
21429 if (it
->area
== TEXT_AREA
)
21430 it
->current_x
+= it
->pixel_width
;
21432 if (extra_line_spacing
> 0)
21434 it
->descent
+= extra_line_spacing
;
21435 if (extra_line_spacing
> it
->max_extra_line_spacing
)
21436 it
->max_extra_line_spacing
= extra_line_spacing
;
21439 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
21440 it
->max_descent
= max (it
->max_descent
, it
->descent
);
21441 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
21442 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
21446 Output LEN glyphs starting at START at the nominal cursor position.
21447 Advance the nominal cursor over the text. The global variable
21448 updated_window contains the window being updated, updated_row is
21449 the glyph row being updated, and updated_area is the area of that
21450 row being updated. */
21453 x_write_glyphs (start
, len
)
21454 struct glyph
*start
;
21459 xassert (updated_window
&& updated_row
);
21462 /* Write glyphs. */
21464 hpos
= start
- updated_row
->glyphs
[updated_area
];
21465 x
= draw_glyphs (updated_window
, output_cursor
.x
,
21466 updated_row
, updated_area
,
21468 DRAW_NORMAL_TEXT
, 0);
21470 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
21471 if (updated_area
== TEXT_AREA
21472 && updated_window
->phys_cursor_on_p
21473 && updated_window
->phys_cursor
.vpos
== output_cursor
.vpos
21474 && updated_window
->phys_cursor
.hpos
>= hpos
21475 && updated_window
->phys_cursor
.hpos
< hpos
+ len
)
21476 updated_window
->phys_cursor_on_p
= 0;
21480 /* Advance the output cursor. */
21481 output_cursor
.hpos
+= len
;
21482 output_cursor
.x
= x
;
21487 Insert LEN glyphs from START at the nominal cursor position. */
21490 x_insert_glyphs (start
, len
)
21491 struct glyph
*start
;
21496 int line_height
, shift_by_width
, shifted_region_width
;
21497 struct glyph_row
*row
;
21498 struct glyph
*glyph
;
21499 int frame_x
, frame_y
;
21502 xassert (updated_window
&& updated_row
);
21504 w
= updated_window
;
21505 f
= XFRAME (WINDOW_FRAME (w
));
21507 /* Get the height of the line we are in. */
21509 line_height
= row
->height
;
21511 /* Get the width of the glyphs to insert. */
21512 shift_by_width
= 0;
21513 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
21514 shift_by_width
+= glyph
->pixel_width
;
21516 /* Get the width of the region to shift right. */
21517 shifted_region_width
= (window_box_width (w
, updated_area
)
21522 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
21523 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
21525 FRAME_RIF (f
)->shift_glyphs_for_insert (f
, frame_x
, frame_y
, shifted_region_width
,
21526 line_height
, shift_by_width
);
21528 /* Write the glyphs. */
21529 hpos
= start
- row
->glyphs
[updated_area
];
21530 draw_glyphs (w
, output_cursor
.x
, row
, updated_area
,
21532 DRAW_NORMAL_TEXT
, 0);
21534 /* Advance the output cursor. */
21535 output_cursor
.hpos
+= len
;
21536 output_cursor
.x
+= shift_by_width
;
21542 Erase the current text line from the nominal cursor position
21543 (inclusive) to pixel column TO_X (exclusive). The idea is that
21544 everything from TO_X onward is already erased.
21546 TO_X is a pixel position relative to updated_area of
21547 updated_window. TO_X == -1 means clear to the end of this area. */
21550 x_clear_end_of_line (to_x
)
21554 struct window
*w
= updated_window
;
21555 int max_x
, min_y
, max_y
;
21556 int from_x
, from_y
, to_y
;
21558 xassert (updated_window
&& updated_row
);
21559 f
= XFRAME (w
->frame
);
21561 if (updated_row
->full_width_p
)
21562 max_x
= WINDOW_TOTAL_WIDTH (w
);
21564 max_x
= window_box_width (w
, updated_area
);
21565 max_y
= window_text_bottom_y (w
);
21567 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
21568 of window. For TO_X > 0, truncate to end of drawing area. */
21574 to_x
= min (to_x
, max_x
);
21576 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
21578 /* Notice if the cursor will be cleared by this operation. */
21579 if (!updated_row
->full_width_p
)
21580 notice_overwritten_cursor (w
, updated_area
,
21581 output_cursor
.x
, -1,
21583 MATRIX_ROW_BOTTOM_Y (updated_row
));
21585 from_x
= output_cursor
.x
;
21587 /* Translate to frame coordinates. */
21588 if (updated_row
->full_width_p
)
21590 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
21591 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
21595 int area_left
= window_box_left (w
, updated_area
);
21596 from_x
+= area_left
;
21600 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
21601 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
21602 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
21604 /* Prevent inadvertently clearing to end of the X window. */
21605 if (to_x
> from_x
&& to_y
> from_y
)
21608 FRAME_RIF (f
)->clear_frame_area (f
, from_x
, from_y
,
21609 to_x
- from_x
, to_y
- from_y
);
21614 #endif /* HAVE_WINDOW_SYSTEM */
21618 /***********************************************************************
21620 ***********************************************************************/
21622 /* Value is the internal representation of the specified cursor type
21623 ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
21624 of the bar cursor. */
21626 static enum text_cursor_kinds
21627 get_specified_cursor_type (arg
, width
)
21631 enum text_cursor_kinds type
;
21636 if (EQ (arg
, Qbox
))
21637 return FILLED_BOX_CURSOR
;
21639 if (EQ (arg
, Qhollow
))
21640 return HOLLOW_BOX_CURSOR
;
21642 if (EQ (arg
, Qbar
))
21649 && EQ (XCAR (arg
), Qbar
)
21650 && INTEGERP (XCDR (arg
))
21651 && XINT (XCDR (arg
)) >= 0)
21653 *width
= XINT (XCDR (arg
));
21657 if (EQ (arg
, Qhbar
))
21660 return HBAR_CURSOR
;
21664 && EQ (XCAR (arg
), Qhbar
)
21665 && INTEGERP (XCDR (arg
))
21666 && XINT (XCDR (arg
)) >= 0)
21668 *width
= XINT (XCDR (arg
));
21669 return HBAR_CURSOR
;
21672 /* Treat anything unknown as "hollow box cursor".
21673 It was bad to signal an error; people have trouble fixing
21674 .Xdefaults with Emacs, when it has something bad in it. */
21675 type
= HOLLOW_BOX_CURSOR
;
21680 /* Set the default cursor types for specified frame. */
21682 set_frame_cursor_types (f
, arg
)
21689 FRAME_DESIRED_CURSOR (f
) = get_specified_cursor_type (arg
, &width
);
21690 FRAME_CURSOR_WIDTH (f
) = width
;
21692 /* By default, set up the blink-off state depending on the on-state. */
21694 tem
= Fassoc (arg
, Vblink_cursor_alist
);
21697 FRAME_BLINK_OFF_CURSOR (f
)
21698 = get_specified_cursor_type (XCDR (tem
), &width
);
21699 FRAME_BLINK_OFF_CURSOR_WIDTH (f
) = width
;
21702 FRAME_BLINK_OFF_CURSOR (f
) = DEFAULT_CURSOR
;
21706 /* Return the cursor we want to be displayed in window W. Return
21707 width of bar/hbar cursor through WIDTH arg. Return with
21708 ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
21709 (i.e. if the `system caret' should track this cursor).
21711 In a mini-buffer window, we want the cursor only to appear if we
21712 are reading input from this window. For the selected window, we
21713 want the cursor type given by the frame parameter or buffer local
21714 setting of cursor-type. If explicitly marked off, draw no cursor.
21715 In all other cases, we want a hollow box cursor. */
21717 static enum text_cursor_kinds
21718 get_window_cursor_type (w
, glyph
, width
, active_cursor
)
21720 struct glyph
*glyph
;
21722 int *active_cursor
;
21724 struct frame
*f
= XFRAME (w
->frame
);
21725 struct buffer
*b
= XBUFFER (w
->buffer
);
21726 int cursor_type
= DEFAULT_CURSOR
;
21727 Lisp_Object alt_cursor
;
21728 int non_selected
= 0;
21730 *active_cursor
= 1;
21733 if (cursor_in_echo_area
21734 && FRAME_HAS_MINIBUF_P (f
)
21735 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
21737 if (w
== XWINDOW (echo_area_window
))
21739 if (EQ (b
->cursor_type
, Qt
) || NILP (b
->cursor_type
))
21741 *width
= FRAME_CURSOR_WIDTH (f
);
21742 return FRAME_DESIRED_CURSOR (f
);
21745 return get_specified_cursor_type (b
->cursor_type
, width
);
21748 *active_cursor
= 0;
21752 /* Detect a nonselected window or nonselected frame. */
21753 else if (w
!= XWINDOW (f
->selected_window
)
21754 #ifdef HAVE_WINDOW_SYSTEM
21755 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
21759 *active_cursor
= 0;
21761 if (MINI_WINDOW_P (w
) && minibuf_level
== 0)
21767 /* Never display a cursor in a window in which cursor-type is nil. */
21768 if (NILP (b
->cursor_type
))
21771 /* Get the normal cursor type for this window. */
21772 if (EQ (b
->cursor_type
, Qt
))
21774 cursor_type
= FRAME_DESIRED_CURSOR (f
);
21775 *width
= FRAME_CURSOR_WIDTH (f
);
21778 cursor_type
= get_specified_cursor_type (b
->cursor_type
, width
);
21780 /* Use cursor-in-non-selected-windows instead
21781 for non-selected window or frame. */
21784 alt_cursor
= b
->cursor_in_non_selected_windows
;
21785 if (!EQ (Qt
, alt_cursor
))
21786 return get_specified_cursor_type (alt_cursor
, width
);
21787 /* t means modify the normal cursor type. */
21788 if (cursor_type
== FILLED_BOX_CURSOR
)
21789 cursor_type
= HOLLOW_BOX_CURSOR
;
21790 else if (cursor_type
== BAR_CURSOR
&& *width
> 1)
21792 return cursor_type
;
21795 /* Use normal cursor if not blinked off. */
21796 if (!w
->cursor_off_p
)
21798 #ifdef HAVE_WINDOW_SYSTEM
21799 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
21801 if (cursor_type
== FILLED_BOX_CURSOR
)
21803 /* Using a block cursor on large images can be very annoying.
21804 So use a hollow cursor for "large" images.
21805 If image is not transparent (no mask), also use hollow cursor. */
21806 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
21807 if (img
!= NULL
&& IMAGEP (img
->spec
))
21809 /* Arbitrarily, interpret "Large" as >32x32 and >NxN
21810 where N = size of default frame font size.
21811 This should cover most of the "tiny" icons people may use. */
21813 || img
->width
> max (32, WINDOW_FRAME_COLUMN_WIDTH (w
))
21814 || img
->height
> max (32, WINDOW_FRAME_LINE_HEIGHT (w
)))
21815 cursor_type
= HOLLOW_BOX_CURSOR
;
21818 else if (cursor_type
!= NO_CURSOR
)
21820 /* Display current only supports BOX and HOLLOW cursors for images.
21821 So for now, unconditionally use a HOLLOW cursor when cursor is
21822 not a solid box cursor. */
21823 cursor_type
= HOLLOW_BOX_CURSOR
;
21827 return cursor_type
;
21830 /* Cursor is blinked off, so determine how to "toggle" it. */
21832 /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist. */
21833 if ((alt_cursor
= Fassoc (b
->cursor_type
, Vblink_cursor_alist
), !NILP (alt_cursor
)))
21834 return get_specified_cursor_type (XCDR (alt_cursor
), width
);
21836 /* Then see if frame has specified a specific blink off cursor type. */
21837 if (FRAME_BLINK_OFF_CURSOR (f
) != DEFAULT_CURSOR
)
21839 *width
= FRAME_BLINK_OFF_CURSOR_WIDTH (f
);
21840 return FRAME_BLINK_OFF_CURSOR (f
);
21844 /* Some people liked having a permanently visible blinking cursor,
21845 while others had very strong opinions against it. So it was
21846 decided to remove it. KFS 2003-09-03 */
21848 /* Finally perform built-in cursor blinking:
21849 filled box <-> hollow box
21850 wide [h]bar <-> narrow [h]bar
21851 narrow [h]bar <-> no cursor
21852 other type <-> no cursor */
21854 if (cursor_type
== FILLED_BOX_CURSOR
)
21855 return HOLLOW_BOX_CURSOR
;
21857 if ((cursor_type
== BAR_CURSOR
|| cursor_type
== HBAR_CURSOR
) && *width
> 1)
21860 return cursor_type
;
21868 #ifdef HAVE_WINDOW_SYSTEM
21870 /* Notice when the text cursor of window W has been completely
21871 overwritten by a drawing operation that outputs glyphs in AREA
21872 starting at X0 and ending at X1 in the line starting at Y0 and
21873 ending at Y1. X coordinates are area-relative. X1 < 0 means all
21874 the rest of the line after X0 has been written. Y coordinates
21875 are window-relative. */
21878 notice_overwritten_cursor (w
, area
, x0
, x1
, y0
, y1
)
21880 enum glyph_row_area area
;
21881 int x0
, y0
, x1
, y1
;
21883 int cx0
, cx1
, cy0
, cy1
;
21884 struct glyph_row
*row
;
21886 if (!w
->phys_cursor_on_p
)
21888 if (area
!= TEXT_AREA
)
21891 if (w
->phys_cursor
.vpos
< 0
21892 || w
->phys_cursor
.vpos
>= w
->current_matrix
->nrows
21893 || (row
= w
->current_matrix
->rows
+ w
->phys_cursor
.vpos
,
21894 !(row
->enabled_p
&& row
->displays_text_p
)))
21897 if (row
->cursor_in_fringe_p
)
21899 row
->cursor_in_fringe_p
= 0;
21900 draw_fringe_bitmap (w
, row
, 0);
21901 w
->phys_cursor_on_p
= 0;
21905 cx0
= w
->phys_cursor
.x
;
21906 cx1
= cx0
+ w
->phys_cursor_width
;
21907 if (x0
> cx0
|| (x1
>= 0 && x1
< cx1
))
21910 /* The cursor image will be completely removed from the
21911 screen if the output area intersects the cursor area in
21912 y-direction. When we draw in [y0 y1[, and some part of
21913 the cursor is at y < y0, that part must have been drawn
21914 before. When scrolling, the cursor is erased before
21915 actually scrolling, so we don't come here. When not
21916 scrolling, the rows above the old cursor row must have
21917 changed, and in this case these rows must have written
21918 over the cursor image.
21920 Likewise if part of the cursor is below y1, with the
21921 exception of the cursor being in the first blank row at
21922 the buffer and window end because update_text_area
21923 doesn't draw that row. (Except when it does, but
21924 that's handled in update_text_area.) */
21926 cy0
= w
->phys_cursor
.y
;
21927 cy1
= cy0
+ w
->phys_cursor_height
;
21928 if ((y0
< cy0
|| y0
>= cy1
) && (y1
<= cy0
|| y1
>= cy1
))
21931 w
->phys_cursor_on_p
= 0;
21934 #endif /* HAVE_WINDOW_SYSTEM */
21937 /************************************************************************
21939 ************************************************************************/
21941 #ifdef HAVE_WINDOW_SYSTEM
21944 Fix the display of area AREA of overlapping row ROW in window W
21945 with respect to the overlapping part OVERLAPS. */
21948 x_fix_overlapping_area (w
, row
, area
, overlaps
)
21950 struct glyph_row
*row
;
21951 enum glyph_row_area area
;
21959 for (i
= 0; i
< row
->used
[area
];)
21961 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
21963 int start
= i
, start_x
= x
;
21967 x
+= row
->glyphs
[area
][i
].pixel_width
;
21970 while (i
< row
->used
[area
]
21971 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
21973 draw_glyphs (w
, start_x
, row
, area
,
21975 DRAW_NORMAL_TEXT
, overlaps
);
21979 x
+= row
->glyphs
[area
][i
].pixel_width
;
21989 Draw the cursor glyph of window W in glyph row ROW. See the
21990 comment of draw_glyphs for the meaning of HL. */
21993 draw_phys_cursor_glyph (w
, row
, hl
)
21995 struct glyph_row
*row
;
21996 enum draw_glyphs_face hl
;
21998 /* If cursor hpos is out of bounds, don't draw garbage. This can
21999 happen in mini-buffer windows when switching between echo area
22000 glyphs and mini-buffer. */
22001 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
22003 int on_p
= w
->phys_cursor_on_p
;
22005 x1
= draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
22006 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
22008 w
->phys_cursor_on_p
= on_p
;
22010 if (hl
== DRAW_CURSOR
)
22011 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
22012 /* When we erase the cursor, and ROW is overlapped by other
22013 rows, make sure that these overlapping parts of other rows
22015 else if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
22017 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
22019 if (row
> w
->current_matrix
->rows
22020 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
22021 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
,
22022 OVERLAPS_ERASED_CURSOR
);
22024 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
22025 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
22026 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
,
22027 OVERLAPS_ERASED_CURSOR
);
22034 Erase the image of a cursor of window W from the screen. */
22037 erase_phys_cursor (w
)
22040 struct frame
*f
= XFRAME (w
->frame
);
22041 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
22042 int hpos
= w
->phys_cursor
.hpos
;
22043 int vpos
= w
->phys_cursor
.vpos
;
22044 int mouse_face_here_p
= 0;
22045 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
22046 struct glyph_row
*cursor_row
;
22047 struct glyph
*cursor_glyph
;
22048 enum draw_glyphs_face hl
;
22050 /* No cursor displayed or row invalidated => nothing to do on the
22052 if (w
->phys_cursor_type
== NO_CURSOR
)
22053 goto mark_cursor_off
;
22055 /* VPOS >= active_glyphs->nrows means that window has been resized.
22056 Don't bother to erase the cursor. */
22057 if (vpos
>= active_glyphs
->nrows
)
22058 goto mark_cursor_off
;
22060 /* If row containing cursor is marked invalid, there is nothing we
22062 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
22063 if (!cursor_row
->enabled_p
)
22064 goto mark_cursor_off
;
22066 /* If line spacing is > 0, old cursor may only be partially visible in
22067 window after split-window. So adjust visible height. */
22068 cursor_row
->visible_height
= min (cursor_row
->visible_height
,
22069 window_text_bottom_y (w
) - cursor_row
->y
);
22071 /* If row is completely invisible, don't attempt to delete a cursor which
22072 isn't there. This can happen if cursor is at top of a window, and
22073 we switch to a buffer with a header line in that window. */
22074 if (cursor_row
->visible_height
<= 0)
22075 goto mark_cursor_off
;
22077 /* If cursor is in the fringe, erase by drawing actual bitmap there. */
22078 if (cursor_row
->cursor_in_fringe_p
)
22080 cursor_row
->cursor_in_fringe_p
= 0;
22081 draw_fringe_bitmap (w
, cursor_row
, 0);
22082 goto mark_cursor_off
;
22085 /* This can happen when the new row is shorter than the old one.
22086 In this case, either draw_glyphs or clear_end_of_line
22087 should have cleared the cursor. Note that we wouldn't be
22088 able to erase the cursor in this case because we don't have a
22089 cursor glyph at hand. */
22090 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
22091 goto mark_cursor_off
;
22093 /* If the cursor is in the mouse face area, redisplay that when
22094 we clear the cursor. */
22095 if (! NILP (dpyinfo
->mouse_face_window
)
22096 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
22097 && (vpos
> dpyinfo
->mouse_face_beg_row
22098 || (vpos
== dpyinfo
->mouse_face_beg_row
22099 && hpos
>= dpyinfo
->mouse_face_beg_col
))
22100 && (vpos
< dpyinfo
->mouse_face_end_row
22101 || (vpos
== dpyinfo
->mouse_face_end_row
22102 && hpos
< dpyinfo
->mouse_face_end_col
))
22103 /* Don't redraw the cursor's spot in mouse face if it is at the
22104 end of a line (on a newline). The cursor appears there, but
22105 mouse highlighting does not. */
22106 && cursor_row
->used
[TEXT_AREA
] > hpos
)
22107 mouse_face_here_p
= 1;
22109 /* Maybe clear the display under the cursor. */
22110 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
22113 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
22116 cursor_glyph
= get_phys_cursor_glyph (w
);
22117 if (cursor_glyph
== NULL
)
22118 goto mark_cursor_off
;
22120 width
= cursor_glyph
->pixel_width
;
22121 left_x
= window_box_left_offset (w
, TEXT_AREA
);
22122 x
= w
->phys_cursor
.x
;
22124 width
-= left_x
- x
;
22125 width
= min (width
, window_box_width (w
, TEXT_AREA
) - x
);
22126 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, cursor_row
->y
));
22127 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, max (x
, left_x
));
22130 FRAME_RIF (f
)->clear_frame_area (f
, x
, y
, width
, cursor_row
->visible_height
);
22133 /* Erase the cursor by redrawing the character underneath it. */
22134 if (mouse_face_here_p
)
22135 hl
= DRAW_MOUSE_FACE
;
22137 hl
= DRAW_NORMAL_TEXT
;
22138 draw_phys_cursor_glyph (w
, cursor_row
, hl
);
22141 w
->phys_cursor_on_p
= 0;
22142 w
->phys_cursor_type
= NO_CURSOR
;
22147 Display or clear cursor of window W. If ON is zero, clear the
22148 cursor. If it is non-zero, display the cursor. If ON is nonzero,
22149 where to put the cursor is specified by HPOS, VPOS, X and Y. */
22152 display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
22154 int on
, hpos
, vpos
, x
, y
;
22156 struct frame
*f
= XFRAME (w
->frame
);
22157 int new_cursor_type
;
22158 int new_cursor_width
;
22160 struct glyph_row
*glyph_row
;
22161 struct glyph
*glyph
;
22163 /* This is pointless on invisible frames, and dangerous on garbaged
22164 windows and frames; in the latter case, the frame or window may
22165 be in the midst of changing its size, and x and y may be off the
22167 if (! FRAME_VISIBLE_P (f
)
22168 || FRAME_GARBAGED_P (f
)
22169 || vpos
>= w
->current_matrix
->nrows
22170 || hpos
>= w
->current_matrix
->matrix_w
)
22173 /* If cursor is off and we want it off, return quickly. */
22174 if (!on
&& !w
->phys_cursor_on_p
)
22177 glyph_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
22178 /* If cursor row is not enabled, we don't really know where to
22179 display the cursor. */
22180 if (!glyph_row
->enabled_p
)
22182 w
->phys_cursor_on_p
= 0;
22187 if (!glyph_row
->exact_window_width_line_p
22188 || hpos
< glyph_row
->used
[TEXT_AREA
])
22189 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
22191 xassert (interrupt_input_blocked
);
22193 /* Set new_cursor_type to the cursor we want to be displayed. */
22194 new_cursor_type
= get_window_cursor_type (w
, glyph
,
22195 &new_cursor_width
, &active_cursor
);
22197 /* If cursor is currently being shown and we don't want it to be or
22198 it is in the wrong place, or the cursor type is not what we want,
22200 if (w
->phys_cursor_on_p
22202 || w
->phys_cursor
.x
!= x
22203 || w
->phys_cursor
.y
!= y
22204 || new_cursor_type
!= w
->phys_cursor_type
22205 || ((new_cursor_type
== BAR_CURSOR
|| new_cursor_type
== HBAR_CURSOR
)
22206 && new_cursor_width
!= w
->phys_cursor_width
)))
22207 erase_phys_cursor (w
);
22209 /* Don't check phys_cursor_on_p here because that flag is only set
22210 to zero in some cases where we know that the cursor has been
22211 completely erased, to avoid the extra work of erasing the cursor
22212 twice. In other words, phys_cursor_on_p can be 1 and the cursor
22213 still not be visible, or it has only been partly erased. */
22216 w
->phys_cursor_ascent
= glyph_row
->ascent
;
22217 w
->phys_cursor_height
= glyph_row
->height
;
22219 /* Set phys_cursor_.* before x_draw_.* is called because some
22220 of them may need the information. */
22221 w
->phys_cursor
.x
= x
;
22222 w
->phys_cursor
.y
= glyph_row
->y
;
22223 w
->phys_cursor
.hpos
= hpos
;
22224 w
->phys_cursor
.vpos
= vpos
;
22227 FRAME_RIF (f
)->draw_window_cursor (w
, glyph_row
, x
, y
,
22228 new_cursor_type
, new_cursor_width
,
22229 on
, active_cursor
);
22233 /* Switch the display of W's cursor on or off, according to the value
22237 update_window_cursor (w
, on
)
22241 /* Don't update cursor in windows whose frame is in the process
22242 of being deleted. */
22243 if (w
->current_matrix
)
22246 display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
22247 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
22253 /* Call update_window_cursor with parameter ON_P on all leaf windows
22254 in the window tree rooted at W. */
22257 update_cursor_in_window_tree (w
, on_p
)
22263 if (!NILP (w
->hchild
))
22264 update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
22265 else if (!NILP (w
->vchild
))
22266 update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
22268 update_window_cursor (w
, on_p
);
22270 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
22276 Display the cursor on window W, or clear it, according to ON_P.
22277 Don't change the cursor's position. */
22280 x_update_cursor (f
, on_p
)
22284 update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
22289 Clear the cursor of window W to background color, and mark the
22290 cursor as not shown. This is used when the text where the cursor
22291 is is about to be rewritten. */
22297 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
22298 update_window_cursor (w
, 0);
22303 Display the active region described by mouse_face_* according to DRAW. */
22306 show_mouse_face (dpyinfo
, draw
)
22307 Display_Info
*dpyinfo
;
22308 enum draw_glyphs_face draw
;
22310 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
22311 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
22313 if (/* If window is in the process of being destroyed, don't bother
22315 w
->current_matrix
!= NULL
22316 /* Don't update mouse highlight if hidden */
22317 && (draw
!= DRAW_MOUSE_FACE
|| !dpyinfo
->mouse_face_hidden
)
22318 /* Recognize when we are called to operate on rows that don't exist
22319 anymore. This can happen when a window is split. */
22320 && dpyinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
22322 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
22323 struct glyph_row
*row
, *first
, *last
;
22325 first
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_beg_row
);
22326 last
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_end_row
);
22328 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
22330 int start_hpos
, end_hpos
, start_x
;
22332 /* For all but the first row, the highlight starts at column 0. */
22335 start_hpos
= dpyinfo
->mouse_face_beg_col
;
22336 start_x
= dpyinfo
->mouse_face_beg_x
;
22345 end_hpos
= dpyinfo
->mouse_face_end_col
;
22348 end_hpos
= row
->used
[TEXT_AREA
];
22349 if (draw
== DRAW_NORMAL_TEXT
)
22350 row
->fill_line_p
= 1; /* Clear to end of line */
22353 if (end_hpos
> start_hpos
)
22355 draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
22356 start_hpos
, end_hpos
,
22360 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
22364 /* When we've written over the cursor, arrange for it to
22365 be displayed again. */
22366 if (phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
22369 display_and_set_cursor (w
, 1,
22370 w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
22371 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
22376 /* Change the mouse cursor. */
22377 if (draw
== DRAW_NORMAL_TEXT
&& !EQ (dpyinfo
->mouse_face_window
, f
->tool_bar_window
))
22378 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->text_cursor
);
22379 else if (draw
== DRAW_MOUSE_FACE
)
22380 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->hand_cursor
);
22382 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->nontext_cursor
);
22386 Clear out the mouse-highlighted active region.
22387 Redraw it un-highlighted first. Value is non-zero if mouse
22388 face was actually drawn unhighlighted. */
22391 clear_mouse_face (dpyinfo
)
22392 Display_Info
*dpyinfo
;
22396 if (!dpyinfo
->mouse_face_hidden
&& !NILP (dpyinfo
->mouse_face_window
))
22398 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
22402 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
22403 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
22404 dpyinfo
->mouse_face_window
= Qnil
;
22405 dpyinfo
->mouse_face_overlay
= Qnil
;
22411 Non-zero if physical cursor of window W is within mouse face. */
22414 cursor_in_mouse_face_p (w
)
22417 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
22418 int in_mouse_face
= 0;
22420 if (WINDOWP (dpyinfo
->mouse_face_window
)
22421 && XWINDOW (dpyinfo
->mouse_face_window
) == w
)
22423 int hpos
= w
->phys_cursor
.hpos
;
22424 int vpos
= w
->phys_cursor
.vpos
;
22426 if (vpos
>= dpyinfo
->mouse_face_beg_row
22427 && vpos
<= dpyinfo
->mouse_face_end_row
22428 && (vpos
> dpyinfo
->mouse_face_beg_row
22429 || hpos
>= dpyinfo
->mouse_face_beg_col
)
22430 && (vpos
< dpyinfo
->mouse_face_end_row
22431 || hpos
< dpyinfo
->mouse_face_end_col
22432 || dpyinfo
->mouse_face_past_end
))
22436 return in_mouse_face
;
22442 /* Find the glyph matrix position of buffer position CHARPOS in window
22443 *W. HPOS, *VPOS, *X, and *Y are set to the positions found. W's
22444 current glyphs must be up to date. If CHARPOS is above window
22445 start return (0, 0, 0, 0). If CHARPOS is after end of W, return end
22446 of last line in W. In the row containing CHARPOS, stop before glyphs
22447 having STOP as object. */
22449 #if 1 /* This is a version of fast_find_position that's more correct
22450 in the presence of hscrolling, for example. I didn't install
22451 it right away because the problem fixed is minor, it failed
22452 in 20.x as well, and I think it's too risky to install
22453 so near the release of 21.1. 2001-09-25 gerd. */
22456 fast_find_position (w
, charpos
, hpos
, vpos
, x
, y
, stop
)
22459 int *hpos
, *vpos
, *x
, *y
;
22462 struct glyph_row
*row
, *first
;
22463 struct glyph
*glyph
, *end
;
22466 first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
22467 if (charpos
< MATRIX_ROW_START_CHARPOS (first
))
22472 *vpos
= MATRIX_ROW_VPOS (first
, w
->current_matrix
);
22476 row
= row_containing_pos (w
, charpos
, first
, NULL
, 0);
22479 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
22483 /* If whole rows or last part of a row came from a display overlay,
22484 row_containing_pos will skip over such rows because their end pos
22485 equals the start pos of the overlay or interval.
22487 Move back if we have a STOP object and previous row's
22488 end glyph came from STOP. */
22491 struct glyph_row
*prev
;
22492 while ((prev
= row
- 1, prev
>= first
)
22493 && MATRIX_ROW_END_CHARPOS (prev
) == charpos
22494 && prev
->used
[TEXT_AREA
] > 0)
22496 struct glyph
*beg
= prev
->glyphs
[TEXT_AREA
];
22497 glyph
= beg
+ prev
->used
[TEXT_AREA
];
22498 while (--glyph
>= beg
22499 && INTEGERP (glyph
->object
));
22501 || !EQ (stop
, glyph
->object
))
22509 *vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
22511 glyph
= row
->glyphs
[TEXT_AREA
];
22512 end
= glyph
+ row
->used
[TEXT_AREA
];
22514 /* Skip over glyphs not having an object at the start of the row.
22515 These are special glyphs like truncation marks on terminal
22517 if (row
->displays_text_p
)
22519 && INTEGERP (glyph
->object
)
22520 && !EQ (stop
, glyph
->object
)
22521 && glyph
->charpos
< 0)
22523 *x
+= glyph
->pixel_width
;
22528 && !INTEGERP (glyph
->object
)
22529 && !EQ (stop
, glyph
->object
)
22530 && (!BUFFERP (glyph
->object
)
22531 || glyph
->charpos
< charpos
))
22533 *x
+= glyph
->pixel_width
;
22537 *hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
22544 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
, stop
)
22547 int *hpos
, *vpos
, *x
, *y
;
22552 int maybe_next_line_p
= 0;
22553 int line_start_position
;
22554 int yb
= window_text_bottom_y (w
);
22555 struct glyph_row
*row
, *best_row
;
22556 int row_vpos
, best_row_vpos
;
22559 row
= best_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
22560 row_vpos
= best_row_vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
22562 while (row
->y
< yb
)
22564 if (row
->used
[TEXT_AREA
])
22565 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
22567 line_start_position
= 0;
22569 if (line_start_position
> pos
)
22571 /* If the position sought is the end of the buffer,
22572 don't include the blank lines at the bottom of the window. */
22573 else if (line_start_position
== pos
22574 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
22576 maybe_next_line_p
= 1;
22579 else if (line_start_position
> 0)
22582 best_row_vpos
= row_vpos
;
22585 if (row
->y
+ row
->height
>= yb
)
22592 /* Find the right column within BEST_ROW. */
22594 current_x
= best_row
->x
;
22595 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
22597 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
22598 int charpos
= glyph
->charpos
;
22600 if (BUFFERP (glyph
->object
))
22602 if (charpos
== pos
)
22605 *vpos
= best_row_vpos
;
22610 else if (charpos
> pos
)
22613 else if (EQ (glyph
->object
, stop
))
22618 current_x
+= glyph
->pixel_width
;
22621 /* If we're looking for the end of the buffer,
22622 and we didn't find it in the line we scanned,
22623 use the start of the following line. */
22624 if (maybe_next_line_p
)
22629 current_x
= best_row
->x
;
22632 *vpos
= best_row_vpos
;
22633 *hpos
= lastcol
+ 1;
22642 /* Find the position of the glyph for position POS in OBJECT in
22643 window W's current matrix, and return in *X, *Y the pixel
22644 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
22646 RIGHT_P non-zero means return the position of the right edge of the
22647 glyph, RIGHT_P zero means return the left edge position.
22649 If no glyph for POS exists in the matrix, return the position of
22650 the glyph with the next smaller position that is in the matrix, if
22651 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
22652 exists in the matrix, return the position of the glyph with the
22653 next larger position in OBJECT.
22655 Value is non-zero if a glyph was found. */
22658 fast_find_string_pos (w
, pos
, object
, hpos
, vpos
, x
, y
, right_p
)
22661 Lisp_Object object
;
22662 int *hpos
, *vpos
, *x
, *y
;
22665 int yb
= window_text_bottom_y (w
);
22666 struct glyph_row
*r
;
22667 struct glyph
*best_glyph
= NULL
;
22668 struct glyph_row
*best_row
= NULL
;
22671 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
22672 r
->enabled_p
&& r
->y
< yb
;
22675 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
22676 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
22679 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
22680 if (EQ (g
->object
, object
))
22682 if (g
->charpos
== pos
)
22689 else if (best_glyph
== NULL
22690 || ((eabs (g
->charpos
- pos
)
22691 < eabs (best_glyph
->charpos
- pos
))
22694 : g
->charpos
> pos
)))
22708 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
22712 *x
+= best_glyph
->pixel_width
;
22717 *vpos
= best_row
- w
->current_matrix
->rows
;
22720 return best_glyph
!= NULL
;
22724 /* See if position X, Y is within a hot-spot of an image. */
22727 on_hot_spot_p (hot_spot
, x
, y
)
22728 Lisp_Object hot_spot
;
22731 if (!CONSP (hot_spot
))
22734 if (EQ (XCAR (hot_spot
), Qrect
))
22736 /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1)) */
22737 Lisp_Object rect
= XCDR (hot_spot
);
22741 if (!CONSP (XCAR (rect
)))
22743 if (!CONSP (XCDR (rect
)))
22745 if (!(tem
= XCAR (XCAR (rect
)), INTEGERP (tem
) && x
>= XINT (tem
)))
22747 if (!(tem
= XCDR (XCAR (rect
)), INTEGERP (tem
) && y
>= XINT (tem
)))
22749 if (!(tem
= XCAR (XCDR (rect
)), INTEGERP (tem
) && x
<= XINT (tem
)))
22751 if (!(tem
= XCDR (XCDR (rect
)), INTEGERP (tem
) && y
<= XINT (tem
)))
22755 else if (EQ (XCAR (hot_spot
), Qcircle
))
22757 /* CDR is (Center . Radius) = ((x0 . y0) . r) */
22758 Lisp_Object circ
= XCDR (hot_spot
);
22759 Lisp_Object lr
, lx0
, ly0
;
22761 && CONSP (XCAR (circ
))
22762 && (lr
= XCDR (circ
), INTEGERP (lr
) || FLOATP (lr
))
22763 && (lx0
= XCAR (XCAR (circ
)), INTEGERP (lx0
))
22764 && (ly0
= XCDR (XCAR (circ
)), INTEGERP (ly0
)))
22766 double r
= XFLOATINT (lr
);
22767 double dx
= XINT (lx0
) - x
;
22768 double dy
= XINT (ly0
) - y
;
22769 return (dx
* dx
+ dy
* dy
<= r
* r
);
22772 else if (EQ (XCAR (hot_spot
), Qpoly
))
22774 /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
22775 if (VECTORP (XCDR (hot_spot
)))
22777 struct Lisp_Vector
*v
= XVECTOR (XCDR (hot_spot
));
22778 Lisp_Object
*poly
= v
->contents
;
22782 Lisp_Object lx
, ly
;
22785 /* Need an even number of coordinates, and at least 3 edges. */
22786 if (n
< 6 || n
& 1)
22789 /* Count edge segments intersecting line from (X,Y) to (X,infinity).
22790 If count is odd, we are inside polygon. Pixels on edges
22791 may or may not be included depending on actual geometry of the
22793 if ((lx
= poly
[n
-2], !INTEGERP (lx
))
22794 || (ly
= poly
[n
-1], !INTEGERP (lx
)))
22796 x0
= XINT (lx
), y0
= XINT (ly
);
22797 for (i
= 0; i
< n
; i
+= 2)
22799 int x1
= x0
, y1
= y0
;
22800 if ((lx
= poly
[i
], !INTEGERP (lx
))
22801 || (ly
= poly
[i
+1], !INTEGERP (ly
)))
22803 x0
= XINT (lx
), y0
= XINT (ly
);
22805 /* Does this segment cross the X line? */
22813 if (y
> y0
&& y
> y1
)
22815 if (y
< y0
+ ((y1
- y0
) * (x
- x0
)) / (x1
- x0
))
22825 find_hot_spot (map
, x
, y
)
22829 while (CONSP (map
))
22831 if (CONSP (XCAR (map
))
22832 && on_hot_spot_p (XCAR (XCAR (map
)), x
, y
))
22840 DEFUN ("lookup-image-map", Flookup_image_map
, Slookup_image_map
,
22842 doc
: /* Lookup in image map MAP coordinates X and Y.
22843 An image map is an alist where each element has the format (AREA ID PLIST).
22844 An AREA is specified as either a rectangle, a circle, or a polygon:
22845 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
22846 pixel coordinates of the upper left and bottom right corners.
22847 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
22848 and the radius of the circle; r may be a float or integer.
22849 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
22850 vector describes one corner in the polygon.
22851 Returns the alist element for the first matching AREA in MAP. */)
22862 return find_hot_spot (map
, XINT (x
), XINT (y
));
22866 /* Display frame CURSOR, optionally using shape defined by POINTER. */
22868 define_frame_cursor1 (f
, cursor
, pointer
)
22871 Lisp_Object pointer
;
22873 /* Do not change cursor shape while dragging mouse. */
22874 if (!NILP (do_mouse_tracking
))
22877 if (!NILP (pointer
))
22879 if (EQ (pointer
, Qarrow
))
22880 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
22881 else if (EQ (pointer
, Qhand
))
22882 cursor
= FRAME_X_OUTPUT (f
)->hand_cursor
;
22883 else if (EQ (pointer
, Qtext
))
22884 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
22885 else if (EQ (pointer
, intern ("hdrag")))
22886 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
22887 #ifdef HAVE_X_WINDOWS
22888 else if (EQ (pointer
, intern ("vdrag")))
22889 cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
22891 else if (EQ (pointer
, intern ("hourglass")))
22892 cursor
= FRAME_X_OUTPUT (f
)->hourglass_cursor
;
22893 else if (EQ (pointer
, Qmodeline
))
22894 cursor
= FRAME_X_OUTPUT (f
)->modeline_cursor
;
22896 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
22899 if (cursor
!= No_Cursor
)
22900 FRAME_RIF (f
)->define_frame_cursor (f
, cursor
);
22903 /* Take proper action when mouse has moved to the mode or header line
22904 or marginal area AREA of window W, x-position X and y-position Y.
22905 X is relative to the start of the text display area of W, so the
22906 width of bitmap areas and scroll bars must be subtracted to get a
22907 position relative to the start of the mode line. */
22910 note_mode_line_or_margin_highlight (window
, x
, y
, area
)
22911 Lisp_Object window
;
22913 enum window_part area
;
22915 struct window
*w
= XWINDOW (window
);
22916 struct frame
*f
= XFRAME (w
->frame
);
22917 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
22918 Cursor cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
22919 Lisp_Object pointer
= Qnil
;
22920 int charpos
, dx
, dy
, width
, height
;
22921 Lisp_Object string
, object
= Qnil
;
22922 Lisp_Object pos
, help
;
22924 Lisp_Object mouse_face
;
22925 int original_x_pixel
= x
;
22926 struct glyph
* glyph
= NULL
, * row_start_glyph
= NULL
;
22927 struct glyph_row
*row
;
22929 if (area
== ON_MODE_LINE
|| area
== ON_HEADER_LINE
)
22934 string
= mode_line_string (w
, area
, &x
, &y
, &charpos
,
22935 &object
, &dx
, &dy
, &width
, &height
);
22937 row
= (area
== ON_MODE_LINE
22938 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
22939 : MATRIX_HEADER_LINE_ROW (w
->current_matrix
));
22942 if (row
->mode_line_p
&& row
->enabled_p
)
22944 glyph
= row_start_glyph
= row
->glyphs
[TEXT_AREA
];
22945 end
= glyph
+ row
->used
[TEXT_AREA
];
22947 for (x0
= original_x_pixel
;
22948 glyph
< end
&& x0
>= glyph
->pixel_width
;
22950 x0
-= glyph
->pixel_width
;
22958 x
-= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
22959 string
= marginal_area_string (w
, area
, &x
, &y
, &charpos
,
22960 &object
, &dx
, &dy
, &width
, &height
);
22965 if (IMAGEP (object
))
22967 Lisp_Object image_map
, hotspot
;
22968 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
22970 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
22972 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
22974 Lisp_Object area_id
, plist
;
22976 area_id
= XCAR (hotspot
);
22977 /* Could check AREA_ID to see if we enter/leave this hot-spot.
22978 If so, we could look for mouse-enter, mouse-leave
22979 properties in PLIST (and do something...). */
22980 hotspot
= XCDR (hotspot
);
22981 if (CONSP (hotspot
)
22982 && (plist
= XCAR (hotspot
), CONSP (plist
)))
22984 pointer
= Fplist_get (plist
, Qpointer
);
22985 if (NILP (pointer
))
22987 help
= Fplist_get (plist
, Qhelp_echo
);
22990 help_echo_string
= help
;
22991 /* Is this correct? ++kfs */
22992 XSETWINDOW (help_echo_window
, w
);
22993 help_echo_object
= w
->buffer
;
22994 help_echo_pos
= charpos
;
22998 if (NILP (pointer
))
22999 pointer
= Fplist_get (XCDR (object
), QCpointer
);
23002 if (STRINGP (string
))
23004 pos
= make_number (charpos
);
23005 /* If we're on a string with `help-echo' text property, arrange
23006 for the help to be displayed. This is done by setting the
23007 global variable help_echo_string to the help string. */
23010 help
= Fget_text_property (pos
, Qhelp_echo
, string
);
23013 help_echo_string
= help
;
23014 XSETWINDOW (help_echo_window
, w
);
23015 help_echo_object
= string
;
23016 help_echo_pos
= charpos
;
23020 if (NILP (pointer
))
23021 pointer
= Fget_text_property (pos
, Qpointer
, string
);
23023 /* Change the mouse pointer according to what is under X/Y. */
23024 if (NILP (pointer
) && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
)))
23027 map
= Fget_text_property (pos
, Qlocal_map
, string
);
23028 if (!KEYMAPP (map
))
23029 map
= Fget_text_property (pos
, Qkeymap
, string
);
23030 if (!KEYMAPP (map
))
23031 cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
23034 /* Change the mouse face according to what is under X/Y. */
23035 mouse_face
= Fget_text_property (pos
, Qmouse_face
, string
);
23036 if (!NILP (mouse_face
)
23037 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
23042 struct glyph
* tmp_glyph
;
23046 int total_pixel_width
;
23051 b
= Fprevious_single_property_change (make_number (charpos
+ 1),
23052 Qmouse_face
, string
, Qnil
);
23054 b
= make_number (0);
23056 e
= Fnext_single_property_change (pos
, Qmouse_face
, string
, Qnil
);
23058 e
= make_number (SCHARS (string
));
23060 /* Calculate the position(glyph position: GPOS) of GLYPH in
23061 displayed string. GPOS is different from CHARPOS.
23063 CHARPOS is the position of glyph in internal string
23064 object. A mode line string format has structures which
23065 is converted to a flatten by emacs lisp interpreter.
23066 The internal string is an element of the structures.
23067 The displayed string is the flatten string. */
23069 if (glyph
> row_start_glyph
)
23071 tmp_glyph
= glyph
- 1;
23072 while (tmp_glyph
>= row_start_glyph
23073 && tmp_glyph
->charpos
>= XINT (b
)
23074 && EQ (tmp_glyph
->object
, glyph
->object
))
23081 /* Calculate the lenght(glyph sequence length: GSEQ_LENGTH) of
23082 displayed string holding GLYPH.
23084 GSEQ_LENGTH is different from SCHARS (STRING).
23085 SCHARS (STRING) returns the length of the internal string. */
23086 for (tmp_glyph
= glyph
, gseq_length
= gpos
;
23087 tmp_glyph
->charpos
< XINT (e
);
23088 tmp_glyph
++, gseq_length
++)
23090 if (!EQ (tmp_glyph
->object
, glyph
->object
))
23094 total_pixel_width
= 0;
23095 for (tmp_glyph
= glyph
- gpos
; tmp_glyph
!= glyph
; tmp_glyph
++)
23096 total_pixel_width
+= tmp_glyph
->pixel_width
;
23098 /* Pre calculation of re-rendering position */
23100 hpos
= (area
== ON_MODE_LINE
23101 ? (w
->current_matrix
)->nrows
- 1
23104 /* If the re-rendering position is included in the last
23105 re-rendering area, we should do nothing. */
23106 if ( EQ (window
, dpyinfo
->mouse_face_window
)
23107 && dpyinfo
->mouse_face_beg_col
<= vpos
23108 && vpos
< dpyinfo
->mouse_face_end_col
23109 && dpyinfo
->mouse_face_beg_row
== hpos
)
23112 if (clear_mouse_face (dpyinfo
))
23113 cursor
= No_Cursor
;
23115 dpyinfo
->mouse_face_beg_col
= vpos
;
23116 dpyinfo
->mouse_face_beg_row
= hpos
;
23118 dpyinfo
->mouse_face_beg_x
= original_x_pixel
- (total_pixel_width
+ dx
);
23119 dpyinfo
->mouse_face_beg_y
= 0;
23121 dpyinfo
->mouse_face_end_col
= vpos
+ gseq_length
;
23122 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_beg_row
;
23124 dpyinfo
->mouse_face_end_x
= 0;
23125 dpyinfo
->mouse_face_end_y
= 0;
23127 dpyinfo
->mouse_face_past_end
= 0;
23128 dpyinfo
->mouse_face_window
= window
;
23130 dpyinfo
->mouse_face_face_id
= face_at_string_position (w
, string
,
23133 glyph
->face_id
, 1);
23134 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
23136 if (NILP (pointer
))
23139 else if ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
23140 clear_mouse_face (dpyinfo
);
23142 define_frame_cursor1 (f
, cursor
, pointer
);
23147 Take proper action when the mouse has moved to position X, Y on
23148 frame F as regards highlighting characters that have mouse-face
23149 properties. Also de-highlighting chars where the mouse was before.
23150 X and Y can be negative or out of range. */
23153 note_mouse_highlight (f
, x
, y
)
23157 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
23158 enum window_part part
;
23159 Lisp_Object window
;
23161 Cursor cursor
= No_Cursor
;
23162 Lisp_Object pointer
= Qnil
; /* Takes precedence over cursor! */
23165 /* When a menu is active, don't highlight because this looks odd. */
23166 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (MAC_OS)
23167 if (popup_activated ())
23171 if (NILP (Vmouse_highlight
)
23172 || !f
->glyphs_initialized_p
)
23175 dpyinfo
->mouse_face_mouse_x
= x
;
23176 dpyinfo
->mouse_face_mouse_y
= y
;
23177 dpyinfo
->mouse_face_mouse_frame
= f
;
23179 if (dpyinfo
->mouse_face_defer
)
23182 if (gc_in_progress
)
23184 dpyinfo
->mouse_face_deferred_gc
= 1;
23188 /* Which window is that in? */
23189 window
= window_from_coordinates (f
, x
, y
, &part
, 0, 0, 1);
23191 /* If we were displaying active text in another window, clear that.
23192 Also clear if we move out of text area in same window. */
23193 if (! EQ (window
, dpyinfo
->mouse_face_window
)
23194 || (part
!= ON_TEXT
&& part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
23195 && !NILP (dpyinfo
->mouse_face_window
)))
23196 clear_mouse_face (dpyinfo
);
23198 /* Not on a window -> return. */
23199 if (!WINDOWP (window
))
23202 /* Reset help_echo_string. It will get recomputed below. */
23203 help_echo_string
= Qnil
;
23205 /* Convert to window-relative pixel coordinates. */
23206 w
= XWINDOW (window
);
23207 frame_to_window_pixel_xy (w
, &x
, &y
);
23209 /* Handle tool-bar window differently since it doesn't display a
23211 if (EQ (window
, f
->tool_bar_window
))
23213 note_tool_bar_highlight (f
, x
, y
);
23217 /* Mouse is on the mode, header line or margin? */
23218 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
23219 || part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
23221 note_mode_line_or_margin_highlight (window
, x
, y
, part
);
23225 if (part
== ON_VERTICAL_BORDER
)
23227 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
23228 help_echo_string
= build_string ("drag-mouse-1: resize");
23230 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
23231 || part
== ON_SCROLL_BAR
)
23232 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
23234 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
23236 /* Are we in a window whose display is up to date?
23237 And verify the buffer's text has not changed. */
23238 b
= XBUFFER (w
->buffer
);
23239 if (part
== ON_TEXT
23240 && EQ (w
->window_end_valid
, w
->buffer
)
23241 && XFASTINT (w
->last_modified
) == BUF_MODIFF (b
)
23242 && XFASTINT (w
->last_overlay_modified
) == BUF_OVERLAY_MODIFF (b
))
23244 int hpos
, vpos
, pos
, i
, dx
, dy
, area
;
23245 struct glyph
*glyph
;
23246 Lisp_Object object
;
23247 Lisp_Object mouse_face
= Qnil
, overlay
= Qnil
, position
;
23248 Lisp_Object
*overlay_vec
= NULL
;
23250 struct buffer
*obuf
;
23251 int obegv
, ozv
, same_region
;
23253 /* Find the glyph under X/Y. */
23254 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &dx
, &dy
, &area
);
23256 /* Look for :pointer property on image. */
23257 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
23259 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
23260 if (img
!= NULL
&& IMAGEP (img
->spec
))
23262 Lisp_Object image_map
, hotspot
;
23263 if ((image_map
= Fplist_get (XCDR (img
->spec
), QCmap
),
23265 && (hotspot
= find_hot_spot (image_map
,
23266 glyph
->slice
.x
+ dx
,
23267 glyph
->slice
.y
+ dy
),
23269 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
23271 Lisp_Object area_id
, plist
;
23273 area_id
= XCAR (hotspot
);
23274 /* Could check AREA_ID to see if we enter/leave this hot-spot.
23275 If so, we could look for mouse-enter, mouse-leave
23276 properties in PLIST (and do something...). */
23277 hotspot
= XCDR (hotspot
);
23278 if (CONSP (hotspot
)
23279 && (plist
= XCAR (hotspot
), CONSP (plist
)))
23281 pointer
= Fplist_get (plist
, Qpointer
);
23282 if (NILP (pointer
))
23284 help_echo_string
= Fplist_get (plist
, Qhelp_echo
);
23285 if (!NILP (help_echo_string
))
23287 help_echo_window
= window
;
23288 help_echo_object
= glyph
->object
;
23289 help_echo_pos
= glyph
->charpos
;
23293 if (NILP (pointer
))
23294 pointer
= Fplist_get (XCDR (img
->spec
), QCpointer
);
23298 /* Clear mouse face if X/Y not over text. */
23300 || area
!= TEXT_AREA
23301 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
23303 if (clear_mouse_face (dpyinfo
))
23304 cursor
= No_Cursor
;
23305 if (NILP (pointer
))
23307 if (area
!= TEXT_AREA
)
23308 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
23310 pointer
= Vvoid_text_area_pointer
;
23315 pos
= glyph
->charpos
;
23316 object
= glyph
->object
;
23317 if (!STRINGP (object
) && !BUFFERP (object
))
23320 /* If we get an out-of-range value, return now; avoid an error. */
23321 if (BUFFERP (object
) && pos
> BUF_Z (b
))
23324 /* Make the window's buffer temporarily current for
23325 overlays_at and compute_char_face. */
23326 obuf
= current_buffer
;
23327 current_buffer
= b
;
23333 /* Is this char mouse-active or does it have help-echo? */
23334 position
= make_number (pos
);
23336 if (BUFFERP (object
))
23338 /* Put all the overlays we want in a vector in overlay_vec. */
23339 GET_OVERLAYS_AT (pos
, overlay_vec
, noverlays
, NULL
, 0);
23340 /* Sort overlays into increasing priority order. */
23341 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
23346 same_region
= (EQ (window
, dpyinfo
->mouse_face_window
)
23347 && vpos
>= dpyinfo
->mouse_face_beg_row
23348 && vpos
<= dpyinfo
->mouse_face_end_row
23349 && (vpos
> dpyinfo
->mouse_face_beg_row
23350 || hpos
>= dpyinfo
->mouse_face_beg_col
)
23351 && (vpos
< dpyinfo
->mouse_face_end_row
23352 || hpos
< dpyinfo
->mouse_face_end_col
23353 || dpyinfo
->mouse_face_past_end
));
23356 cursor
= No_Cursor
;
23358 /* Check mouse-face highlighting. */
23360 /* If there exists an overlay with mouse-face overlapping
23361 the one we are currently highlighting, we have to
23362 check if we enter the overlapping overlay, and then
23363 highlight only that. */
23364 || (OVERLAYP (dpyinfo
->mouse_face_overlay
)
23365 && mouse_face_overlay_overlaps (dpyinfo
->mouse_face_overlay
)))
23367 /* Find the highest priority overlay that has a mouse-face
23370 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
23372 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
23373 if (!NILP (mouse_face
))
23374 overlay
= overlay_vec
[i
];
23377 /* If we're actually highlighting the same overlay as
23378 before, there's no need to do that again. */
23379 if (!NILP (overlay
)
23380 && EQ (overlay
, dpyinfo
->mouse_face_overlay
))
23381 goto check_help_echo
;
23383 dpyinfo
->mouse_face_overlay
= overlay
;
23385 /* Clear the display of the old active region, if any. */
23386 if (clear_mouse_face (dpyinfo
))
23387 cursor
= No_Cursor
;
23389 /* If no overlay applies, get a text property. */
23390 if (NILP (overlay
))
23391 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
23393 /* Handle the overlay case. */
23394 if (!NILP (overlay
))
23396 /* Find the range of text around this char that
23397 should be active. */
23398 Lisp_Object before
, after
;
23401 before
= Foverlay_start (overlay
);
23402 after
= Foverlay_end (overlay
);
23403 /* Record this as the current active region. */
23404 fast_find_position (w
, XFASTINT (before
),
23405 &dpyinfo
->mouse_face_beg_col
,
23406 &dpyinfo
->mouse_face_beg_row
,
23407 &dpyinfo
->mouse_face_beg_x
,
23408 &dpyinfo
->mouse_face_beg_y
, Qnil
);
23410 dpyinfo
->mouse_face_past_end
23411 = !fast_find_position (w
, XFASTINT (after
),
23412 &dpyinfo
->mouse_face_end_col
,
23413 &dpyinfo
->mouse_face_end_row
,
23414 &dpyinfo
->mouse_face_end_x
,
23415 &dpyinfo
->mouse_face_end_y
, Qnil
);
23416 dpyinfo
->mouse_face_window
= window
;
23418 dpyinfo
->mouse_face_face_id
23419 = face_at_buffer_position (w
, pos
, 0, 0,
23421 !dpyinfo
->mouse_face_hidden
);
23423 /* Display it as active. */
23424 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
23425 cursor
= No_Cursor
;
23427 /* Handle the text property case. */
23428 else if (!NILP (mouse_face
) && BUFFERP (object
))
23430 /* Find the range of text around this char that
23431 should be active. */
23432 Lisp_Object before
, after
, beginning
, end
;
23435 beginning
= Fmarker_position (w
->start
);
23436 end
= make_number (BUF_Z (XBUFFER (object
))
23437 - XFASTINT (w
->window_end_pos
));
23439 = Fprevious_single_property_change (make_number (pos
+ 1),
23441 object
, beginning
);
23443 = Fnext_single_property_change (position
, Qmouse_face
,
23446 /* Record this as the current active region. */
23447 fast_find_position (w
, XFASTINT (before
),
23448 &dpyinfo
->mouse_face_beg_col
,
23449 &dpyinfo
->mouse_face_beg_row
,
23450 &dpyinfo
->mouse_face_beg_x
,
23451 &dpyinfo
->mouse_face_beg_y
, Qnil
);
23452 dpyinfo
->mouse_face_past_end
23453 = !fast_find_position (w
, XFASTINT (after
),
23454 &dpyinfo
->mouse_face_end_col
,
23455 &dpyinfo
->mouse_face_end_row
,
23456 &dpyinfo
->mouse_face_end_x
,
23457 &dpyinfo
->mouse_face_end_y
, Qnil
);
23458 dpyinfo
->mouse_face_window
= window
;
23460 if (BUFFERP (object
))
23461 dpyinfo
->mouse_face_face_id
23462 = face_at_buffer_position (w
, pos
, 0, 0,
23464 !dpyinfo
->mouse_face_hidden
);
23466 /* Display it as active. */
23467 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
23468 cursor
= No_Cursor
;
23470 else if (!NILP (mouse_face
) && STRINGP (object
))
23475 b
= Fprevious_single_property_change (make_number (pos
+ 1),
23478 e
= Fnext_single_property_change (position
, Qmouse_face
,
23481 b
= make_number (0);
23483 e
= make_number (SCHARS (object
) - 1);
23485 fast_find_string_pos (w
, XINT (b
), object
,
23486 &dpyinfo
->mouse_face_beg_col
,
23487 &dpyinfo
->mouse_face_beg_row
,
23488 &dpyinfo
->mouse_face_beg_x
,
23489 &dpyinfo
->mouse_face_beg_y
, 0);
23490 fast_find_string_pos (w
, XINT (e
), object
,
23491 &dpyinfo
->mouse_face_end_col
,
23492 &dpyinfo
->mouse_face_end_row
,
23493 &dpyinfo
->mouse_face_end_x
,
23494 &dpyinfo
->mouse_face_end_y
, 1);
23495 dpyinfo
->mouse_face_past_end
= 0;
23496 dpyinfo
->mouse_face_window
= window
;
23497 dpyinfo
->mouse_face_face_id
23498 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
23499 glyph
->face_id
, 1);
23500 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
23501 cursor
= No_Cursor
;
23503 else if (STRINGP (object
) && NILP (mouse_face
))
23505 /* A string which doesn't have mouse-face, but
23506 the text ``under'' it might have. */
23507 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
23508 int start
= MATRIX_ROW_START_CHARPOS (r
);
23510 pos
= string_buffer_position (w
, object
, start
);
23512 mouse_face
= get_char_property_and_overlay (make_number (pos
),
23516 if (!NILP (mouse_face
) && !NILP (overlay
))
23518 Lisp_Object before
= Foverlay_start (overlay
);
23519 Lisp_Object after
= Foverlay_end (overlay
);
23522 /* Note that we might not be able to find position
23523 BEFORE in the glyph matrix if the overlay is
23524 entirely covered by a `display' property. In
23525 this case, we overshoot. So let's stop in
23526 the glyph matrix before glyphs for OBJECT. */
23527 fast_find_position (w
, XFASTINT (before
),
23528 &dpyinfo
->mouse_face_beg_col
,
23529 &dpyinfo
->mouse_face_beg_row
,
23530 &dpyinfo
->mouse_face_beg_x
,
23531 &dpyinfo
->mouse_face_beg_y
,
23534 dpyinfo
->mouse_face_past_end
23535 = !fast_find_position (w
, XFASTINT (after
),
23536 &dpyinfo
->mouse_face_end_col
,
23537 &dpyinfo
->mouse_face_end_row
,
23538 &dpyinfo
->mouse_face_end_x
,
23539 &dpyinfo
->mouse_face_end_y
,
23541 dpyinfo
->mouse_face_window
= window
;
23542 dpyinfo
->mouse_face_face_id
23543 = face_at_buffer_position (w
, pos
, 0, 0,
23545 !dpyinfo
->mouse_face_hidden
);
23547 /* Display it as active. */
23548 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
23549 cursor
= No_Cursor
;
23556 /* Look for a `help-echo' property. */
23557 if (NILP (help_echo_string
)) {
23558 Lisp_Object help
, overlay
;
23560 /* Check overlays first. */
23561 help
= overlay
= Qnil
;
23562 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
23564 overlay
= overlay_vec
[i
];
23565 help
= Foverlay_get (overlay
, Qhelp_echo
);
23570 help_echo_string
= help
;
23571 help_echo_window
= window
;
23572 help_echo_object
= overlay
;
23573 help_echo_pos
= pos
;
23577 Lisp_Object object
= glyph
->object
;
23578 int charpos
= glyph
->charpos
;
23580 /* Try text properties. */
23581 if (STRINGP (object
)
23583 && charpos
< SCHARS (object
))
23585 help
= Fget_text_property (make_number (charpos
),
23586 Qhelp_echo
, object
);
23589 /* If the string itself doesn't specify a help-echo,
23590 see if the buffer text ``under'' it does. */
23591 struct glyph_row
*r
23592 = MATRIX_ROW (w
->current_matrix
, vpos
);
23593 int start
= MATRIX_ROW_START_CHARPOS (r
);
23594 int pos
= string_buffer_position (w
, object
, start
);
23597 help
= Fget_char_property (make_number (pos
),
23598 Qhelp_echo
, w
->buffer
);
23602 object
= w
->buffer
;
23607 else if (BUFFERP (object
)
23610 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
23615 help_echo_string
= help
;
23616 help_echo_window
= window
;
23617 help_echo_object
= object
;
23618 help_echo_pos
= charpos
;
23623 /* Look for a `pointer' property. */
23624 if (NILP (pointer
))
23626 /* Check overlays first. */
23627 for (i
= noverlays
- 1; i
>= 0 && NILP (pointer
); --i
)
23628 pointer
= Foverlay_get (overlay_vec
[i
], Qpointer
);
23630 if (NILP (pointer
))
23632 Lisp_Object object
= glyph
->object
;
23633 int charpos
= glyph
->charpos
;
23635 /* Try text properties. */
23636 if (STRINGP (object
)
23638 && charpos
< SCHARS (object
))
23640 pointer
= Fget_text_property (make_number (charpos
),
23642 if (NILP (pointer
))
23644 /* If the string itself doesn't specify a pointer,
23645 see if the buffer text ``under'' it does. */
23646 struct glyph_row
*r
23647 = MATRIX_ROW (w
->current_matrix
, vpos
);
23648 int start
= MATRIX_ROW_START_CHARPOS (r
);
23649 int pos
= string_buffer_position (w
, object
, start
);
23651 pointer
= Fget_char_property (make_number (pos
),
23652 Qpointer
, w
->buffer
);
23655 else if (BUFFERP (object
)
23658 pointer
= Fget_text_property (make_number (charpos
),
23665 current_buffer
= obuf
;
23670 define_frame_cursor1 (f
, cursor
, pointer
);
23675 Clear any mouse-face on window W. This function is part of the
23676 redisplay interface, and is called from try_window_id and similar
23677 functions to ensure the mouse-highlight is off. */
23680 x_clear_window_mouse_face (w
)
23683 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
23684 Lisp_Object window
;
23687 XSETWINDOW (window
, w
);
23688 if (EQ (window
, dpyinfo
->mouse_face_window
))
23689 clear_mouse_face (dpyinfo
);
23695 Just discard the mouse face information for frame F, if any.
23696 This is used when the size of F is changed. */
23699 cancel_mouse_face (f
)
23702 Lisp_Object window
;
23703 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
23705 window
= dpyinfo
->mouse_face_window
;
23706 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
23708 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
23709 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
23710 dpyinfo
->mouse_face_window
= Qnil
;
23715 #endif /* HAVE_WINDOW_SYSTEM */
23718 /***********************************************************************
23720 ***********************************************************************/
23722 #ifdef HAVE_WINDOW_SYSTEM
23724 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
23725 which intersects rectangle R. R is in window-relative coordinates. */
23728 expose_area (w
, row
, r
, area
)
23730 struct glyph_row
*row
;
23732 enum glyph_row_area area
;
23734 struct glyph
*first
= row
->glyphs
[area
];
23735 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
23736 struct glyph
*last
;
23737 int first_x
, start_x
, x
;
23739 if (area
== TEXT_AREA
&& row
->fill_line_p
)
23740 /* If row extends face to end of line write the whole line. */
23741 draw_glyphs (w
, 0, row
, area
,
23742 0, row
->used
[area
],
23743 DRAW_NORMAL_TEXT
, 0);
23746 /* Set START_X to the window-relative start position for drawing glyphs of
23747 AREA. The first glyph of the text area can be partially visible.
23748 The first glyphs of other areas cannot. */
23749 start_x
= window_box_left_offset (w
, area
);
23751 if (area
== TEXT_AREA
)
23754 /* Find the first glyph that must be redrawn. */
23756 && x
+ first
->pixel_width
< r
->x
)
23758 x
+= first
->pixel_width
;
23762 /* Find the last one. */
23766 && x
< r
->x
+ r
->width
)
23768 x
+= last
->pixel_width
;
23774 draw_glyphs (w
, first_x
- start_x
, row
, area
,
23775 first
- row
->glyphs
[area
], last
- row
->glyphs
[area
],
23776 DRAW_NORMAL_TEXT
, 0);
23781 /* Redraw the parts of the glyph row ROW on window W intersecting
23782 rectangle R. R is in window-relative coordinates. Value is
23783 non-zero if mouse-face was overwritten. */
23786 expose_line (w
, row
, r
)
23788 struct glyph_row
*row
;
23791 xassert (row
->enabled_p
);
23793 if (row
->mode_line_p
|| w
->pseudo_window_p
)
23794 draw_glyphs (w
, 0, row
, TEXT_AREA
,
23795 0, row
->used
[TEXT_AREA
],
23796 DRAW_NORMAL_TEXT
, 0);
23799 if (row
->used
[LEFT_MARGIN_AREA
])
23800 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
23801 if (row
->used
[TEXT_AREA
])
23802 expose_area (w
, row
, r
, TEXT_AREA
);
23803 if (row
->used
[RIGHT_MARGIN_AREA
])
23804 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
23805 draw_row_fringe_bitmaps (w
, row
);
23808 return row
->mouse_face_p
;
23812 /* Redraw those parts of glyphs rows during expose event handling that
23813 overlap other rows. Redrawing of an exposed line writes over parts
23814 of lines overlapping that exposed line; this function fixes that.
23816 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
23817 row in W's current matrix that is exposed and overlaps other rows.
23818 LAST_OVERLAPPING_ROW is the last such row. */
23821 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
, r
)
23823 struct glyph_row
*first_overlapping_row
;
23824 struct glyph_row
*last_overlapping_row
;
23827 struct glyph_row
*row
;
23829 for (row
= first_overlapping_row
; row
<= last_overlapping_row
; ++row
)
23830 if (row
->overlapping_p
)
23832 xassert (row
->enabled_p
&& !row
->mode_line_p
);
23835 if (row
->used
[LEFT_MARGIN_AREA
])
23836 x_fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, OVERLAPS_BOTH
);
23838 if (row
->used
[TEXT_AREA
])
23839 x_fix_overlapping_area (w
, row
, TEXT_AREA
, OVERLAPS_BOTH
);
23841 if (row
->used
[RIGHT_MARGIN_AREA
])
23842 x_fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, OVERLAPS_BOTH
);
23848 /* Return non-zero if W's cursor intersects rectangle R. */
23851 phys_cursor_in_rect_p (w
, r
)
23855 XRectangle cr
, result
;
23856 struct glyph
*cursor_glyph
;
23858 cursor_glyph
= get_phys_cursor_glyph (w
);
23861 /* r is relative to W's box, but w->phys_cursor.x is relative
23862 to left edge of W's TEXT area. Adjust it. */
23863 cr
.x
= window_box_left_offset (w
, TEXT_AREA
) + w
->phys_cursor
.x
;
23864 cr
.y
= w
->phys_cursor
.y
;
23865 cr
.width
= cursor_glyph
->pixel_width
;
23866 cr
.height
= w
->phys_cursor_height
;
23867 /* ++KFS: W32 version used W32-specific IntersectRect here, but
23868 I assume the effect is the same -- and this is portable. */
23869 return x_intersect_rectangles (&cr
, r
, &result
);
23871 /* If we don't understand the format, pretend we're not in the hot-spot. */
23877 Draw a vertical window border to the right of window W if W doesn't
23878 have vertical scroll bars. */
23881 x_draw_vertical_border (w
)
23884 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
23886 /* We could do better, if we knew what type of scroll-bar the adjacent
23887 windows (on either side) have... But we don't :-(
23888 However, I think this works ok. ++KFS 2003-04-25 */
23890 /* Redraw borders between horizontally adjacent windows. Don't
23891 do it for frames with vertical scroll bars because either the
23892 right scroll bar of a window, or the left scroll bar of its
23893 neighbor will suffice as a border. */
23894 if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w
->frame
)))
23897 if (!WINDOW_RIGHTMOST_P (w
)
23898 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
23900 int x0
, x1
, y0
, y1
;
23902 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
23905 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
23908 FRAME_RIF (f
)->draw_vertical_window_border (w
, x1
, y0
, y1
);
23910 else if (!WINDOW_LEFTMOST_P (w
)
23911 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
23913 int x0
, x1
, y0
, y1
;
23915 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
23918 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
23921 FRAME_RIF (f
)->draw_vertical_window_border (w
, x0
, y0
, y1
);
23926 /* Redraw the part of window W intersection rectangle FR. Pixel
23927 coordinates in FR are frame-relative. Call this function with
23928 input blocked. Value is non-zero if the exposure overwrites
23932 expose_window (w
, fr
)
23936 struct frame
*f
= XFRAME (w
->frame
);
23938 int mouse_face_overwritten_p
= 0;
23940 /* If window is not yet fully initialized, do nothing. This can
23941 happen when toolkit scroll bars are used and a window is split.
23942 Reconfiguring the scroll bar will generate an expose for a newly
23944 if (w
->current_matrix
== NULL
)
23947 /* When we're currently updating the window, display and current
23948 matrix usually don't agree. Arrange for a thorough display
23950 if (w
== updated_window
)
23952 SET_FRAME_GARBAGED (f
);
23956 /* Frame-relative pixel rectangle of W. */
23957 wr
.x
= WINDOW_LEFT_EDGE_X (w
);
23958 wr
.y
= WINDOW_TOP_EDGE_Y (w
);
23959 wr
.width
= WINDOW_TOTAL_WIDTH (w
);
23960 wr
.height
= WINDOW_TOTAL_HEIGHT (w
);
23962 if (x_intersect_rectangles (fr
, &wr
, &r
))
23964 int yb
= window_text_bottom_y (w
);
23965 struct glyph_row
*row
;
23966 int cursor_cleared_p
;
23967 struct glyph_row
*first_overlapping_row
, *last_overlapping_row
;
23969 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
23970 r
.x
, r
.y
, r
.width
, r
.height
));
23972 /* Convert to window coordinates. */
23973 r
.x
-= WINDOW_LEFT_EDGE_X (w
);
23974 r
.y
-= WINDOW_TOP_EDGE_Y (w
);
23976 /* Turn off the cursor. */
23977 if (!w
->pseudo_window_p
23978 && phys_cursor_in_rect_p (w
, &r
))
23980 x_clear_cursor (w
);
23981 cursor_cleared_p
= 1;
23984 cursor_cleared_p
= 0;
23986 /* Update lines intersecting rectangle R. */
23987 first_overlapping_row
= last_overlapping_row
= NULL
;
23988 for (row
= w
->current_matrix
->rows
;
23993 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
23995 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
23996 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
23997 || (r
.y
>= y0
&& r
.y
< y1
)
23998 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
24000 /* A header line may be overlapping, but there is no need
24001 to fix overlapping areas for them. KFS 2005-02-12 */
24002 if (row
->overlapping_p
&& !row
->mode_line_p
)
24004 if (first_overlapping_row
== NULL
)
24005 first_overlapping_row
= row
;
24006 last_overlapping_row
= row
;
24010 if (expose_line (w
, row
, &r
))
24011 mouse_face_overwritten_p
= 1;
24014 else if (row
->overlapping_p
)
24016 /* We must redraw a row overlapping the exposed area. */
24018 ? y0
+ row
->phys_height
> r
.y
24019 : y0
+ row
->ascent
- row
->phys_ascent
< r
.y
+r
.height
)
24021 if (first_overlapping_row
== NULL
)
24022 first_overlapping_row
= row
;
24023 last_overlapping_row
= row
;
24031 /* Display the mode line if there is one. */
24032 if (WINDOW_WANTS_MODELINE_P (w
)
24033 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
24035 && row
->y
< r
.y
+ r
.height
)
24037 if (expose_line (w
, row
, &r
))
24038 mouse_face_overwritten_p
= 1;
24041 if (!w
->pseudo_window_p
)
24043 /* Fix the display of overlapping rows. */
24044 if (first_overlapping_row
)
24045 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
,
24048 /* Draw border between windows. */
24049 x_draw_vertical_border (w
);
24051 /* Turn the cursor on again. */
24052 if (cursor_cleared_p
)
24053 update_window_cursor (w
, 1);
24057 return mouse_face_overwritten_p
;
24062 /* Redraw (parts) of all windows in the window tree rooted at W that
24063 intersect R. R contains frame pixel coordinates. Value is
24064 non-zero if the exposure overwrites mouse-face. */
24067 expose_window_tree (w
, r
)
24071 struct frame
*f
= XFRAME (w
->frame
);
24072 int mouse_face_overwritten_p
= 0;
24074 while (w
&& !FRAME_GARBAGED_P (f
))
24076 if (!NILP (w
->hchild
))
24077 mouse_face_overwritten_p
24078 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
24079 else if (!NILP (w
->vchild
))
24080 mouse_face_overwritten_p
24081 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
24083 mouse_face_overwritten_p
|= expose_window (w
, r
);
24085 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
24088 return mouse_face_overwritten_p
;
24093 Redisplay an exposed area of frame F. X and Y are the upper-left
24094 corner of the exposed rectangle. W and H are width and height of
24095 the exposed area. All are pixel values. W or H zero means redraw
24096 the entire frame. */
24099 expose_frame (f
, x
, y
, w
, h
)
24104 int mouse_face_overwritten_p
= 0;
24106 TRACE ((stderr
, "expose_frame "));
24108 /* No need to redraw if frame will be redrawn soon. */
24109 if (FRAME_GARBAGED_P (f
))
24111 TRACE ((stderr
, " garbaged\n"));
24115 /* If basic faces haven't been realized yet, there is no point in
24116 trying to redraw anything. This can happen when we get an expose
24117 event while Emacs is starting, e.g. by moving another window. */
24118 if (FRAME_FACE_CACHE (f
) == NULL
24119 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
24121 TRACE ((stderr
, " no faces\n"));
24125 if (w
== 0 || h
== 0)
24128 r
.width
= FRAME_COLUMN_WIDTH (f
) * FRAME_COLS (f
);
24129 r
.height
= FRAME_LINE_HEIGHT (f
) * FRAME_LINES (f
);
24139 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
24140 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
24142 if (WINDOWP (f
->tool_bar_window
))
24143 mouse_face_overwritten_p
24144 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
24146 #ifdef HAVE_X_WINDOWS
24148 #ifndef USE_X_TOOLKIT
24149 if (WINDOWP (f
->menu_bar_window
))
24150 mouse_face_overwritten_p
24151 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
24152 #endif /* not USE_X_TOOLKIT */
24156 /* Some window managers support a focus-follows-mouse style with
24157 delayed raising of frames. Imagine a partially obscured frame,
24158 and moving the mouse into partially obscured mouse-face on that
24159 frame. The visible part of the mouse-face will be highlighted,
24160 then the WM raises the obscured frame. With at least one WM, KDE
24161 2.1, Emacs is not getting any event for the raising of the frame
24162 (even tried with SubstructureRedirectMask), only Expose events.
24163 These expose events will draw text normally, i.e. not
24164 highlighted. Which means we must redo the highlight here.
24165 Subsume it under ``we love X''. --gerd 2001-08-15 */
24166 /* Included in Windows version because Windows most likely does not
24167 do the right thing if any third party tool offers
24168 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
24169 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
24171 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
24172 if (f
== dpyinfo
->mouse_face_mouse_frame
)
24174 int x
= dpyinfo
->mouse_face_mouse_x
;
24175 int y
= dpyinfo
->mouse_face_mouse_y
;
24176 clear_mouse_face (dpyinfo
);
24177 note_mouse_highlight (f
, x
, y
);
24184 Determine the intersection of two rectangles R1 and R2. Return
24185 the intersection in *RESULT. Value is non-zero if RESULT is not
24189 x_intersect_rectangles (r1
, r2
, result
)
24190 XRectangle
*r1
, *r2
, *result
;
24192 XRectangle
*left
, *right
;
24193 XRectangle
*upper
, *lower
;
24194 int intersection_p
= 0;
24196 /* Rearrange so that R1 is the left-most rectangle. */
24198 left
= r1
, right
= r2
;
24200 left
= r2
, right
= r1
;
24202 /* X0 of the intersection is right.x0, if this is inside R1,
24203 otherwise there is no intersection. */
24204 if (right
->x
<= left
->x
+ left
->width
)
24206 result
->x
= right
->x
;
24208 /* The right end of the intersection is the minimum of the
24209 the right ends of left and right. */
24210 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
24213 /* Same game for Y. */
24215 upper
= r1
, lower
= r2
;
24217 upper
= r2
, lower
= r1
;
24219 /* The upper end of the intersection is lower.y0, if this is inside
24220 of upper. Otherwise, there is no intersection. */
24221 if (lower
->y
<= upper
->y
+ upper
->height
)
24223 result
->y
= lower
->y
;
24225 /* The lower end of the intersection is the minimum of the lower
24226 ends of upper and lower. */
24227 result
->height
= (min (lower
->y
+ lower
->height
,
24228 upper
->y
+ upper
->height
)
24230 intersection_p
= 1;
24234 return intersection_p
;
24237 #endif /* HAVE_WINDOW_SYSTEM */
24240 /***********************************************************************
24242 ***********************************************************************/
24247 Vwith_echo_area_save_vector
= Qnil
;
24248 staticpro (&Vwith_echo_area_save_vector
);
24250 Vmessage_stack
= Qnil
;
24251 staticpro (&Vmessage_stack
);
24253 Qinhibit_redisplay
= intern ("inhibit-redisplay");
24254 staticpro (&Qinhibit_redisplay
);
24256 message_dolog_marker1
= Fmake_marker ();
24257 staticpro (&message_dolog_marker1
);
24258 message_dolog_marker2
= Fmake_marker ();
24259 staticpro (&message_dolog_marker2
);
24260 message_dolog_marker3
= Fmake_marker ();
24261 staticpro (&message_dolog_marker3
);
24264 defsubr (&Sdump_frame_glyph_matrix
);
24265 defsubr (&Sdump_glyph_matrix
);
24266 defsubr (&Sdump_glyph_row
);
24267 defsubr (&Sdump_tool_bar_row
);
24268 defsubr (&Strace_redisplay
);
24269 defsubr (&Strace_to_stderr
);
24271 #ifdef HAVE_WINDOW_SYSTEM
24272 defsubr (&Stool_bar_lines_needed
);
24273 defsubr (&Slookup_image_map
);
24275 defsubr (&Sformat_mode_line
);
24276 defsubr (&Sinvisible_p
);
24278 staticpro (&Qmenu_bar_update_hook
);
24279 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
24281 staticpro (&Qoverriding_terminal_local_map
);
24282 Qoverriding_terminal_local_map
= intern ("overriding-terminal-local-map");
24284 staticpro (&Qoverriding_local_map
);
24285 Qoverriding_local_map
= intern ("overriding-local-map");
24287 staticpro (&Qwindow_scroll_functions
);
24288 Qwindow_scroll_functions
= intern ("window-scroll-functions");
24290 staticpro (&Qredisplay_end_trigger_functions
);
24291 Qredisplay_end_trigger_functions
= intern ("redisplay-end-trigger-functions");
24293 staticpro (&Qinhibit_point_motion_hooks
);
24294 Qinhibit_point_motion_hooks
= intern ("inhibit-point-motion-hooks");
24296 QCdata
= intern (":data");
24297 staticpro (&QCdata
);
24298 Qdisplay
= intern ("display");
24299 staticpro (&Qdisplay
);
24300 Qspace_width
= intern ("space-width");
24301 staticpro (&Qspace_width
);
24302 Qraise
= intern ("raise");
24303 staticpro (&Qraise
);
24304 Qslice
= intern ("slice");
24305 staticpro (&Qslice
);
24306 Qspace
= intern ("space");
24307 staticpro (&Qspace
);
24308 Qmargin
= intern ("margin");
24309 staticpro (&Qmargin
);
24310 Qpointer
= intern ("pointer");
24311 staticpro (&Qpointer
);
24312 Qleft_margin
= intern ("left-margin");
24313 staticpro (&Qleft_margin
);
24314 Qright_margin
= intern ("right-margin");
24315 staticpro (&Qright_margin
);
24316 Qcenter
= intern ("center");
24317 staticpro (&Qcenter
);
24318 Qline_height
= intern ("line-height");
24319 staticpro (&Qline_height
);
24320 QCalign_to
= intern (":align-to");
24321 staticpro (&QCalign_to
);
24322 QCrelative_width
= intern (":relative-width");
24323 staticpro (&QCrelative_width
);
24324 QCrelative_height
= intern (":relative-height");
24325 staticpro (&QCrelative_height
);
24326 QCeval
= intern (":eval");
24327 staticpro (&QCeval
);
24328 QCpropertize
= intern (":propertize");
24329 staticpro (&QCpropertize
);
24330 QCfile
= intern (":file");
24331 staticpro (&QCfile
);
24332 Qfontified
= intern ("fontified");
24333 staticpro (&Qfontified
);
24334 Qfontification_functions
= intern ("fontification-functions");
24335 staticpro (&Qfontification_functions
);
24336 Qtrailing_whitespace
= intern ("trailing-whitespace");
24337 staticpro (&Qtrailing_whitespace
);
24338 Qescape_glyph
= intern ("escape-glyph");
24339 staticpro (&Qescape_glyph
);
24340 Qnobreak_space
= intern ("nobreak-space");
24341 staticpro (&Qnobreak_space
);
24342 Qimage
= intern ("image");
24343 staticpro (&Qimage
);
24344 QCmap
= intern (":map");
24345 staticpro (&QCmap
);
24346 QCpointer
= intern (":pointer");
24347 staticpro (&QCpointer
);
24348 Qrect
= intern ("rect");
24349 staticpro (&Qrect
);
24350 Qcircle
= intern ("circle");
24351 staticpro (&Qcircle
);
24352 Qpoly
= intern ("poly");
24353 staticpro (&Qpoly
);
24354 Qmessage_truncate_lines
= intern ("message-truncate-lines");
24355 staticpro (&Qmessage_truncate_lines
);
24356 Qgrow_only
= intern ("grow-only");
24357 staticpro (&Qgrow_only
);
24358 Qinhibit_menubar_update
= intern ("inhibit-menubar-update");
24359 staticpro (&Qinhibit_menubar_update
);
24360 Qinhibit_eval_during_redisplay
= intern ("inhibit-eval-during-redisplay");
24361 staticpro (&Qinhibit_eval_during_redisplay
);
24362 Qposition
= intern ("position");
24363 staticpro (&Qposition
);
24364 Qbuffer_position
= intern ("buffer-position");
24365 staticpro (&Qbuffer_position
);
24366 Qobject
= intern ("object");
24367 staticpro (&Qobject
);
24368 Qbar
= intern ("bar");
24370 Qhbar
= intern ("hbar");
24371 staticpro (&Qhbar
);
24372 Qbox
= intern ("box");
24374 Qhollow
= intern ("hollow");
24375 staticpro (&Qhollow
);
24376 Qhand
= intern ("hand");
24377 staticpro (&Qhand
);
24378 Qarrow
= intern ("arrow");
24379 staticpro (&Qarrow
);
24380 Qtext
= intern ("text");
24381 staticpro (&Qtext
);
24382 Qrisky_local_variable
= intern ("risky-local-variable");
24383 staticpro (&Qrisky_local_variable
);
24384 Qinhibit_free_realized_faces
= intern ("inhibit-free-realized-faces");
24385 staticpro (&Qinhibit_free_realized_faces
);
24387 list_of_error
= Fcons (Fcons (intern ("error"),
24388 Fcons (intern ("void-variable"), Qnil
)),
24390 staticpro (&list_of_error
);
24392 Qlast_arrow_position
= intern ("last-arrow-position");
24393 staticpro (&Qlast_arrow_position
);
24394 Qlast_arrow_string
= intern ("last-arrow-string");
24395 staticpro (&Qlast_arrow_string
);
24397 Qoverlay_arrow_string
= intern ("overlay-arrow-string");
24398 staticpro (&Qoverlay_arrow_string
);
24399 Qoverlay_arrow_bitmap
= intern ("overlay-arrow-bitmap");
24400 staticpro (&Qoverlay_arrow_bitmap
);
24402 echo_buffer
[0] = echo_buffer
[1] = Qnil
;
24403 staticpro (&echo_buffer
[0]);
24404 staticpro (&echo_buffer
[1]);
24406 echo_area_buffer
[0] = echo_area_buffer
[1] = Qnil
;
24407 staticpro (&echo_area_buffer
[0]);
24408 staticpro (&echo_area_buffer
[1]);
24410 Vmessages_buffer_name
= build_string ("*Messages*");
24411 staticpro (&Vmessages_buffer_name
);
24413 mode_line_proptrans_alist
= Qnil
;
24414 staticpro (&mode_line_proptrans_alist
);
24415 mode_line_string_list
= Qnil
;
24416 staticpro (&mode_line_string_list
);
24417 mode_line_string_face
= Qnil
;
24418 staticpro (&mode_line_string_face
);
24419 mode_line_string_face_prop
= Qnil
;
24420 staticpro (&mode_line_string_face_prop
);
24421 Vmode_line_unwind_vector
= Qnil
;
24422 staticpro (&Vmode_line_unwind_vector
);
24424 help_echo_string
= Qnil
;
24425 staticpro (&help_echo_string
);
24426 help_echo_object
= Qnil
;
24427 staticpro (&help_echo_object
);
24428 help_echo_window
= Qnil
;
24429 staticpro (&help_echo_window
);
24430 previous_help_echo_string
= Qnil
;
24431 staticpro (&previous_help_echo_string
);
24432 help_echo_pos
= -1;
24434 #ifdef HAVE_WINDOW_SYSTEM
24435 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
24436 doc
: /* *Non-nil means draw block cursor as wide as the glyph under it.
24437 For example, if a block cursor is over a tab, it will be drawn as
24438 wide as that tab on the display. */);
24439 x_stretch_cursor_p
= 0;
24442 DEFVAR_LISP ("show-trailing-whitespace", &Vshow_trailing_whitespace
,
24443 doc
: /* *Non-nil means highlight trailing whitespace.
24444 The face used for trailing whitespace is `trailing-whitespace'. */);
24445 Vshow_trailing_whitespace
= Qnil
;
24447 DEFVAR_LISP ("nobreak-char-display", &Vnobreak_char_display
,
24448 doc
: /* *Control highlighting of nobreak space and soft hyphen.
24449 A value of t means highlight the character itself (for nobreak space,
24450 use face `nobreak-space').
24451 A value of nil means no highlighting.
24452 Other values mean display the escape glyph followed by an ordinary
24453 space or ordinary hyphen. */);
24454 Vnobreak_char_display
= Qt
;
24456 DEFVAR_LISP ("void-text-area-pointer", &Vvoid_text_area_pointer
,
24457 doc
: /* *The pointer shape to show in void text areas.
24458 A value of nil means to show the text pointer. Other options are `arrow',
24459 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'. */);
24460 Vvoid_text_area_pointer
= Qarrow
;
24462 DEFVAR_LISP ("inhibit-redisplay", &Vinhibit_redisplay
,
24463 doc
: /* Non-nil means don't actually do any redisplay.
24464 This is used for internal purposes. */);
24465 Vinhibit_redisplay
= Qnil
;
24467 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
24468 doc
: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
24469 Vglobal_mode_string
= Qnil
;
24471 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
24472 doc
: /* Marker for where to display an arrow on top of the buffer text.
24473 This must be the beginning of a line in order to work.
24474 See also `overlay-arrow-string'. */);
24475 Voverlay_arrow_position
= Qnil
;
24477 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
24478 doc
: /* String to display as an arrow in non-window frames.
24479 See also `overlay-arrow-position'. */);
24480 Voverlay_arrow_string
= build_string ("=>");
24482 DEFVAR_LISP ("overlay-arrow-variable-list", &Voverlay_arrow_variable_list
,
24483 doc
: /* List of variables (symbols) which hold markers for overlay arrows.
24484 The symbols on this list are examined during redisplay to determine
24485 where to display overlay arrows. */);
24486 Voverlay_arrow_variable_list
24487 = Fcons (intern ("overlay-arrow-position"), Qnil
);
24489 DEFVAR_INT ("scroll-step", &scroll_step
,
24490 doc
: /* *The number of lines to try scrolling a window by when point moves out.
24491 If that fails to bring point back on frame, point is centered instead.
24492 If this is zero, point is always centered after it moves off frame.
24493 If you want scrolling to always be a line at a time, you should set
24494 `scroll-conservatively' to a large value rather than set this to 1. */);
24496 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively
,
24497 doc
: /* *Scroll up to this many lines, to bring point back on screen.
24498 A value of zero means to scroll the text to center point vertically
24499 in the window. */);
24500 scroll_conservatively
= 0;
24502 DEFVAR_INT ("scroll-margin", &scroll_margin
,
24503 doc
: /* *Number of lines of margin at the top and bottom of a window.
24504 Recenter the window whenever point gets within this many lines
24505 of the top or bottom of the window. */);
24508 DEFVAR_LISP ("display-pixels-per-inch", &Vdisplay_pixels_per_inch
,
24509 doc
: /* Pixels per inch value for non-window system displays.
24510 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI). */);
24511 Vdisplay_pixels_per_inch
= make_float (72.0);
24514 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, doc
: /* Don't ask. */);
24517 DEFVAR_BOOL ("truncate-partial-width-windows",
24518 &truncate_partial_width_windows
,
24519 doc
: /* *Non-nil means truncate lines in all windows less than full frame wide. */);
24520 truncate_partial_width_windows
= 1;
24522 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
24523 doc
: /* When nil, display the mode-line/header-line/menu-bar in the default face.
24524 Any other value means to use the appropriate face, `mode-line',
24525 `header-line', or `menu' respectively. */);
24526 mode_line_inverse_video
= 1;
24528 DEFVAR_LISP ("line-number-display-limit", &Vline_number_display_limit
,
24529 doc
: /* *Maximum buffer size for which line number should be displayed.
24530 If the buffer is bigger than this, the line number does not appear
24531 in the mode line. A value of nil means no limit. */);
24532 Vline_number_display_limit
= Qnil
;
24534 DEFVAR_INT ("line-number-display-limit-width",
24535 &line_number_display_limit_width
,
24536 doc
: /* *Maximum line width (in characters) for line number display.
24537 If the average length of the lines near point is bigger than this, then the
24538 line number may be omitted from the mode line. */);
24539 line_number_display_limit_width
= 200;
24541 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
24542 doc
: /* *Non-nil means highlight region even in nonselected windows. */);
24543 highlight_nonselected_windows
= 0;
24545 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
24546 doc
: /* Non-nil if more than one frame is visible on this display.
24547 Minibuffer-only frames don't count, but iconified frames do.
24548 This variable is not guaranteed to be accurate except while processing
24549 `frame-title-format' and `icon-title-format'. */);
24551 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
24552 doc
: /* Template for displaying the title bar of visible frames.
24553 \(Assuming the window manager supports this feature.)
24555 This variable has the same structure as `mode-line-format', except that
24556 the %c and %l constructs are ignored. It is used only on frames for
24557 which no explicit name has been set \(see `modify-frame-parameters'). */);
24559 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
24560 doc
: /* Template for displaying the title bar of an iconified frame.
24561 \(Assuming the window manager supports this feature.)
24562 This variable has the same structure as `mode-line-format' (which see),
24563 and is used only on frames for which no explicit name has been set
24564 \(see `modify-frame-parameters'). */);
24566 = Vframe_title_format
24567 = Fcons (intern ("multiple-frames"),
24568 Fcons (build_string ("%b"),
24569 Fcons (Fcons (empty_unibyte_string
,
24570 Fcons (intern ("invocation-name"),
24571 Fcons (build_string ("@"),
24572 Fcons (intern ("system-name"),
24576 DEFVAR_LISP ("message-log-max", &Vmessage_log_max
,
24577 doc
: /* Maximum number of lines to keep in the message log buffer.
24578 If nil, disable message logging. If t, log messages but don't truncate
24579 the buffer when it becomes large. */);
24580 Vmessage_log_max
= make_number (100);
24582 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions
,
24583 doc
: /* Functions called before redisplay, if window sizes have changed.
24584 The value should be a list of functions that take one argument.
24585 Just before redisplay, for each frame, if any of its windows have changed
24586 size since the last redisplay, or have been split or deleted,
24587 all the functions in the list are called, with the frame as argument. */);
24588 Vwindow_size_change_functions
= Qnil
;
24590 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions
,
24591 doc
: /* List of functions to call before redisplaying a window with scrolling.
24592 Each function is called with two arguments, the window
24593 and its new display-start position. Note that the value of `window-end'
24594 is not valid when these functions are called. */);
24595 Vwindow_scroll_functions
= Qnil
;
24597 DEFVAR_LISP ("redisplay-end-trigger-functions", &Vredisplay_end_trigger_functions
,
24598 doc
: /* Functions called when redisplay of a window reaches the end trigger.
24599 Each function is called with two arguments, the window and the end trigger value.
24600 See `set-window-redisplay-end-trigger'. */);
24601 Vredisplay_end_trigger_functions
= Qnil
;
24603 DEFVAR_LISP ("mouse-autoselect-window", &Vmouse_autoselect_window
,
24604 doc
: /* *Non-nil means autoselect window with mouse pointer.
24605 If nil, do not autoselect windows.
24606 A positive number means delay autoselection by that many seconds: a
24607 window is autoselected only after the mouse has remained in that
24608 window for the duration of the delay.
24609 A negative number has a similar effect, but causes windows to be
24610 autoselected only after the mouse has stopped moving. \(Because of
24611 the way Emacs compares mouse events, you will occasionally wait twice
24612 that time before the window gets selected.\)
24613 Any other value means to autoselect window instantaneously when the
24614 mouse pointer enters it.
24616 Autoselection selects the minibuffer only if it is active, and never
24617 unselects the minibuffer if it is active.
24619 When customizing this variable make sure that the actual value of
24620 `focus-follows-mouse' matches the behavior of your window manager. */);
24621 Vmouse_autoselect_window
= Qnil
;
24623 DEFVAR_LISP ("auto-resize-tool-bars", &Vauto_resize_tool_bars
,
24624 doc
: /* *Non-nil means automatically resize tool-bars.
24625 This dynamically changes the tool-bar's height to the minimum height
24626 that is needed to make all tool-bar items visible.
24627 If value is `grow-only', the tool-bar's height is only increased
24628 automatically; to decrease the tool-bar height, use \\[recenter]. */);
24629 Vauto_resize_tool_bars
= Qt
;
24631 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", &auto_raise_tool_bar_buttons_p
,
24632 doc
: /* *Non-nil means raise tool-bar buttons when the mouse moves over them. */);
24633 auto_raise_tool_bar_buttons_p
= 1;
24635 DEFVAR_BOOL ("make-cursor-line-fully-visible", &make_cursor_line_fully_visible_p
,
24636 doc
: /* *Non-nil means to scroll (recenter) cursor line if it is not fully visible. */);
24637 make_cursor_line_fully_visible_p
= 1;
24639 DEFVAR_LISP ("tool-bar-border", &Vtool_bar_border
,
24640 doc
: /* *Border below tool-bar in pixels.
24641 If an integer, use it as the height of the border.
24642 If it is one of `internal-border-width' or `border-width', use the
24643 value of the corresponding frame parameter.
24644 Otherwise, no border is added below the tool-bar. */);
24645 Vtool_bar_border
= Qinternal_border_width
;
24647 DEFVAR_LISP ("tool-bar-button-margin", &Vtool_bar_button_margin
,
24648 doc
: /* *Margin around tool-bar buttons in pixels.
24649 If an integer, use that for both horizontal and vertical margins.
24650 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
24651 HORZ specifying the horizontal margin, and VERT specifying the
24652 vertical margin. */);
24653 Vtool_bar_button_margin
= make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
24655 DEFVAR_INT ("tool-bar-button-relief", &tool_bar_button_relief
,
24656 doc
: /* *Relief thickness of tool-bar buttons. */);
24657 tool_bar_button_relief
= DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
24659 DEFVAR_LISP ("fontification-functions", &Vfontification_functions
,
24660 doc
: /* List of functions to call to fontify regions of text.
24661 Each function is called with one argument POS. Functions must
24662 fontify a region starting at POS in the current buffer, and give
24663 fontified regions the property `fontified'. */);
24664 Vfontification_functions
= Qnil
;
24665 Fmake_variable_buffer_local (Qfontification_functions
);
24667 DEFVAR_BOOL ("unibyte-display-via-language-environment",
24668 &unibyte_display_via_language_environment
,
24669 doc
: /* *Non-nil means display unibyte text according to language environment.
24670 Specifically this means that unibyte non-ASCII characters
24671 are displayed by converting them to the equivalent multibyte characters
24672 according to the current language environment. As a result, they are
24673 displayed according to the current fontset. */);
24674 unibyte_display_via_language_environment
= 0;
24676 DEFVAR_LISP ("max-mini-window-height", &Vmax_mini_window_height
,
24677 doc
: /* *Maximum height for resizing mini-windows.
24678 If a float, it specifies a fraction of the mini-window frame's height.
24679 If an integer, it specifies a number of lines. */);
24680 Vmax_mini_window_height
= make_float (0.25);
24682 DEFVAR_LISP ("resize-mini-windows", &Vresize_mini_windows
,
24683 doc
: /* *How to resize mini-windows.
24684 A value of nil means don't automatically resize mini-windows.
24685 A value of t means resize them to fit the text displayed in them.
24686 A value of `grow-only', the default, means let mini-windows grow
24687 only, until their display becomes empty, at which point the windows
24688 go back to their normal size. */);
24689 Vresize_mini_windows
= Qgrow_only
;
24691 DEFVAR_LISP ("blink-cursor-alist", &Vblink_cursor_alist
,
24692 doc
: /* Alist specifying how to blink the cursor off.
24693 Each element has the form (ON-STATE . OFF-STATE). Whenever the
24694 `cursor-type' frame-parameter or variable equals ON-STATE,
24695 comparing using `equal', Emacs uses OFF-STATE to specify
24696 how to blink it off. ON-STATE and OFF-STATE are values for
24697 the `cursor-type' frame parameter.
24699 If a frame's ON-STATE has no entry in this list,
24700 the frame's other specifications determine how to blink the cursor off. */);
24701 Vblink_cursor_alist
= Qnil
;
24703 DEFVAR_BOOL ("auto-hscroll-mode", &automatic_hscrolling_p
,
24704 doc
: /* *Non-nil means scroll the display automatically to make point visible. */);
24705 automatic_hscrolling_p
= 1;
24707 DEFVAR_INT ("hscroll-margin", &hscroll_margin
,
24708 doc
: /* *How many columns away from the window edge point is allowed to get
24709 before automatic hscrolling will horizontally scroll the window. */);
24710 hscroll_margin
= 5;
24712 DEFVAR_LISP ("hscroll-step", &Vhscroll_step
,
24713 doc
: /* *How many columns to scroll the window when point gets too close to the edge.
24714 When point is less than `hscroll-margin' columns from the window
24715 edge, automatic hscrolling will scroll the window by the amount of columns
24716 determined by this variable. If its value is a positive integer, scroll that
24717 many columns. If it's a positive floating-point number, it specifies the
24718 fraction of the window's width to scroll. If it's nil or zero, point will be
24719 centered horizontally after the scroll. Any other value, including negative
24720 numbers, are treated as if the value were zero.
24722 Automatic hscrolling always moves point outside the scroll margin, so if
24723 point was more than scroll step columns inside the margin, the window will
24724 scroll more than the value given by the scroll step.
24726 Note that the lower bound for automatic hscrolling specified by `scroll-left'
24727 and `scroll-right' overrides this variable's effect. */);
24728 Vhscroll_step
= make_number (0);
24730 DEFVAR_BOOL ("message-truncate-lines", &message_truncate_lines
,
24731 doc
: /* If non-nil, messages are truncated instead of resizing the echo area.
24732 Bind this around calls to `message' to let it take effect. */);
24733 message_truncate_lines
= 0;
24735 DEFVAR_LISP ("menu-bar-update-hook", &Vmenu_bar_update_hook
,
24736 doc
: /* Normal hook run to update the menu bar definitions.
24737 Redisplay runs this hook before it redisplays the menu bar.
24738 This is used to update submenus such as Buffers,
24739 whose contents depend on various data. */);
24740 Vmenu_bar_update_hook
= Qnil
;
24742 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
24743 doc
: /* Frame for which we are updating a menu.
24744 The enable predicate for a menu binding should check this variable. */);
24745 Vmenu_updating_frame
= Qnil
;
24747 DEFVAR_BOOL ("inhibit-menubar-update", &inhibit_menubar_update
,
24748 doc
: /* Non-nil means don't update menu bars. Internal use only. */);
24749 inhibit_menubar_update
= 0;
24751 DEFVAR_BOOL ("inhibit-eval-during-redisplay", &inhibit_eval_during_redisplay
,
24752 doc
: /* Non-nil means don't eval Lisp during redisplay. */);
24753 inhibit_eval_during_redisplay
= 0;
24755 DEFVAR_BOOL ("inhibit-free-realized-faces", &inhibit_free_realized_faces
,
24756 doc
: /* Non-nil means don't free realized faces. Internal use only. */);
24757 inhibit_free_realized_faces
= 0;
24760 DEFVAR_BOOL ("inhibit-try-window-id", &inhibit_try_window_id
,
24761 doc
: /* Inhibit try_window_id display optimization. */);
24762 inhibit_try_window_id
= 0;
24764 DEFVAR_BOOL ("inhibit-try-window-reusing", &inhibit_try_window_reusing
,
24765 doc
: /* Inhibit try_window_reusing display optimization. */);
24766 inhibit_try_window_reusing
= 0;
24768 DEFVAR_BOOL ("inhibit-try-cursor-movement", &inhibit_try_cursor_movement
,
24769 doc
: /* Inhibit try_cursor_movement display optimization. */);
24770 inhibit_try_cursor_movement
= 0;
24771 #endif /* GLYPH_DEBUG */
24773 DEFVAR_INT ("overline-margin", &overline_margin
,
24774 doc
: /* *Space between overline and text, in pixels.
24775 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
24776 margin to the caracter height. */);
24777 overline_margin
= 2;
24781 /* Initialize this module when Emacs starts. */
24786 Lisp_Object root_window
;
24787 struct window
*mini_w
;
24789 current_header_line_height
= current_mode_line_height
= -1;
24791 CHARPOS (this_line_start_pos
) = 0;
24793 mini_w
= XWINDOW (minibuf_window
);
24794 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
24796 if (!noninteractive
)
24798 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
24801 XWINDOW (root_window
)->top_line
= make_number (FRAME_TOP_MARGIN (f
));
24802 set_window_height (root_window
,
24803 FRAME_LINES (f
) - 1 - FRAME_TOP_MARGIN (f
),
24805 mini_w
->top_line
= make_number (FRAME_LINES (f
) - 1);
24806 set_window_height (minibuf_window
, 1, 0);
24808 XWINDOW (root_window
)->total_cols
= make_number (FRAME_COLS (f
));
24809 mini_w
->total_cols
= make_number (FRAME_COLS (f
));
24811 scratch_glyph_row
.glyphs
[TEXT_AREA
] = scratch_glyphs
;
24812 scratch_glyph_row
.glyphs
[TEXT_AREA
+ 1]
24813 = scratch_glyphs
+ MAX_SCRATCH_GLYPHS
;
24815 /* The default ellipsis glyphs `...'. */
24816 for (i
= 0; i
< 3; ++i
)
24817 default_invis_vector
[i
] = make_number ('.');
24821 /* Allocate the buffer for frame titles.
24822 Also used for `format-mode-line'. */
24824 mode_line_noprop_buf
= (char *) xmalloc (size
);
24825 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
24826 mode_line_noprop_ptr
= mode_line_noprop_buf
;
24827 mode_line_target
= MODE_LINE_DISPLAY
;
24830 help_echo_showing_p
= 0;
24834 /* arch-tag: eacc864d-bb6a-4b74-894a-1a4399a1358b
24835 (do not change this comment) */